drivers/net/phy/motorcomm.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Motorcomm 8511/8521 PHY driver.
   4  *
   5  * Author: Peter Geis <pgwipeout@gmail.com>
   6  * Author: Frank <Frank.Sae@motor-comm.com>
   7  */
   8
   9 #include <linux/etherdevice.h>
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/phy.h>
  13
  14 #define PHY_ID_YT8511           0x0000010a
  15 #define PHY_ID_YT8521                           0x0000011A
  16
  17 /* YT8521 Register Overview
  18  *      UTP Register space      |       FIBER Register space
  19  *  ------------------------------------------------------------
  20  * |    UTP MII                 |       FIBER MII               |
  21  * |    UTP MMD                 |                               |
  22  * |    UTP Extended            |       FIBER Extended          |
  23  *  ------------------------------------------------------------
  24  * |                    Common Extended                         |
  25  *  ------------------------------------------------------------
  26  */
  27
  28 /* 0x10 ~ 0x15 , 0x1E and 0x1F are common MII registers of yt phy */
  29
  30 /* Specific Function Control Register */
  31 #define YTPHY_SPECIFIC_FUNCTION_CONTROL_REG     0x10
  32
  33 /* 2b00 Manual MDI configuration
  34  * 2b01 Manual MDIX configuration
  35  * 2b10 Reserved
  36  * 2b11 Enable automatic crossover for all modes  *default*
  37  */
  38 #define YTPHY_SFCR_MDI_CROSSOVER_MODE_MASK      (BIT(6) | BIT(5))
  39 #define YTPHY_SFCR_CROSSOVER_EN                 BIT(3)
  40 #define YTPHY_SFCR_SQE_TEST_EN                  BIT(2)
  41 #define YTPHY_SFCR_POLARITY_REVERSAL_EN         BIT(1)
  42 #define YTPHY_SFCR_JABBER_DIS                   BIT(0)
  43
  44 /* Specific Status Register */
  45 #define YTPHY_SPECIFIC_STATUS_REG               0x11
  46 #define YTPHY_SSR_SPEED_MODE_OFFSET             14
  47
  48 #define YTPHY_SSR_SPEED_MODE_MASK               (BIT(15) | BIT(14))
  49 #define YTPHY_SSR_SPEED_10M                     0x0
  50 #define YTPHY_SSR_SPEED_100M                    0x1
  51 #define YTPHY_SSR_SPEED_1000M                   0x2
  52 #define YTPHY_SSR_DUPLEX_OFFSET                 13
  53 #define YTPHY_SSR_DUPLEX                        BIT(13)
  54 #define YTPHY_SSR_PAGE_RECEIVED                 BIT(12)
  55 #define YTPHY_SSR_SPEED_DUPLEX_RESOLVED         BIT(11)
  56 #define YTPHY_SSR_LINK                          BIT(10)
  57 #define YTPHY_SSR_MDIX_CROSSOVER                BIT(6)
  58 #define YTPHY_SSR_DOWNGRADE                     BIT(5)
  59 #define YTPHY_SSR_TRANSMIT_PAUSE                BIT(3)
  60 #define YTPHY_SSR_RECEIVE_PAUSE                 BIT(2)
  61 #define YTPHY_SSR_POLARITY                      BIT(1)
  62 #define YTPHY_SSR_JABBER                        BIT(0)
  63
  64 /* Interrupt enable Register */
  65 #define YTPHY_INTERRUPT_ENABLE_REG              0x12
  66 #define YTPHY_IER_WOL                           BIT(6)
  67
  68 /* Interrupt Status Register */
  69 #define YTPHY_INTERRUPT_STATUS_REG              0x13
  70 #define YTPHY_ISR_AUTONEG_ERR                   BIT(15)
  71 #define YTPHY_ISR_SPEED_CHANGED                 BIT(14)
  72 #define YTPHY_ISR_DUPLEX_CHANGED                BIT(13)
  73 #define YTPHY_ISR_PAGE_RECEIVED                 BIT(12)
  74 #define YTPHY_ISR_LINK_FAILED                   BIT(11)
  75 #define YTPHY_ISR_LINK_SUCCESSED                BIT(10)
  76 #define YTPHY_ISR_WOL                           BIT(6)
  77 #define YTPHY_ISR_WIRESPEED_DOWNGRADE           BIT(5)
  78 #define YTPHY_ISR_SERDES_LINK_FAILED            BIT(3)
  79 #define YTPHY_ISR_SERDES_LINK_SUCCESSED         BIT(2)
  80 #define YTPHY_ISR_POLARITY_CHANGED              BIT(1)
  81 #define YTPHY_ISR_JABBER_HAPPENED               BIT(0)
  82
  83 /* Speed Auto Downgrade Control Register */
  84 #define YTPHY_SPEED_AUTO_DOWNGRADE_CONTROL_REG  0x14
  85 #define YTPHY_SADCR_SPEED_DOWNGRADE_EN          BIT(5)
  86
  87 /* If these bits are set to 3, the PHY attempts five times ( 3(set value) +
  88  * additional 2) before downgrading, default 0x3
  89  */
  90 #define YTPHY_SADCR_SPEED_RETRY_LIMIT           (0x3 << 2)
  91
  92 /* Rx Error Counter Register */
  93 #define YTPHY_RX_ERROR_COUNTER_REG              0x15
  94
  95 /* Extended Register's Address Offset Register */
  96 #define YTPHY_PAGE_SELECT                       0x1E
  97
  98 /* Extended Register's Data Register */
  99 #define YTPHY_PAGE_DATA                         0x1F
 100
 101 /* FIBER Auto-Negotiation link partner ability */
 102 #define YTPHY_FLPA_PAUSE                        (0x3 << 7)
 103 #define YTPHY_FLPA_ASYM_PAUSE                   (0x2 << 7)
 104
 105 #define YT8511_PAGE_SELECT      0x1e
 106 #define YT8511_PAGE             0x1f
 107 #define YT8511_EXT_CLK_GATE     0x0c
 108 #define YT8511_EXT_DELAY_DRIVE  0x0d
 109 #define YT8511_EXT_SLEEP_CTRL   0x27
 110
 111 /* 2b00 25m from pll
 112  * 2b01 25m from xtl *default*
 113  * 2b10 62.m from pll
 114  * 2b11 125m from pll
 115  */
 116 #define YT8511_CLK_125M         (BIT(2) | BIT(1))
 117 #define YT8511_PLLON_SLP        BIT(14)
 118
 119 /* RX Delay enabled = 1.8ns 1000T, 8ns 10/100T */
 120 #define YT8511_DELAY_RX         BIT(0)
 121
 122 /* TX Gig-E Delay is bits 7:4, default 0x5
 123  * TX Fast-E Delay is bits 15:12, default 0xf
 124  * Delay = 150ps * N - 250ps
 125  * On = 2000ps, off = 50ps
 126  */
 127 #define YT8511_DELAY_GE_TX_EN   (0xf << 4)
 128 #define YT8511_DELAY_GE_TX_DIS  (0x2 << 4)
 129 #define YT8511_DELAY_FE_TX_EN   (0xf << 12)
 130 #define YT8511_DELAY_FE_TX_DIS  (0x2 << 12)
 131
 132 /* Extended register is different from MMD Register and MII Register.
 133  * We can use ytphy_read_ext/ytphy_write_ext/ytphy_modify_ext function to
 134  * operate extended register.
 135  * Extended Register  start
 136  */
 137
 138 /* Phy gmii clock gating Register */
 139 #define YT8521_CLOCK_GATING_REG                 0xC
 140 #define YT8521_CGR_RX_CLK_EN                    BIT(12)
 141
 142 #define YT8521_EXTREG_SLEEP_CONTROL1_REG        0x27
 143 #define YT8521_ESC1R_SLEEP_SW                   BIT(15)
 144 #define YT8521_ESC1R_PLLON_SLP                  BIT(14)
 145
 146 /* Phy fiber Link timer cfg2 Register */
 147 #define YT8521_LINK_TIMER_CFG2_REG              0xA5
 148 #define YT8521_LTCR_EN_AUTOSEN                  BIT(15)
 149
 150 /* 0xA000, 0xA001, 0xA003 ,and 0xA006 ~ 0xA00A  are common ext registers
 151  * of yt8521 phy. There is no need to switch reg space when operating these
 152  * registers.
 153  */
 154
 155 #define YT8521_REG_SPACE_SELECT_REG             0xA000
 156 #define YT8521_RSSR_SPACE_MASK                  BIT(1)
 157 #define YT8521_RSSR_FIBER_SPACE                 (0x1 << 1)
 158 #define YT8521_RSSR_UTP_SPACE                   (0x0 << 1)
 159 #define YT8521_RSSR_TO_BE_ARBITRATED            (0xFF)
 160
 161 #define YT8521_CHIP_CONFIG_REG                  0xA001
 162 #define YT8521_CCR_SW_RST                       BIT(15)
 163 #define YT8521_CCR_RXC_DLY_EN                   BIT(8)
 164
 165 #define YT8521_CCR_MODE_SEL_MASK                (BIT(2) | BIT(1) | BIT(0))
 166 #define YT8521_CCR_MODE_UTP_TO_RGMII            0
 167 #define YT8521_CCR_MODE_FIBER_TO_RGMII          1
 168 #define YT8521_CCR_MODE_UTP_FIBER_TO_RGMII      2
 169 #define YT8521_CCR_MODE_UTP_TO_SGMII            3
 170 #define YT8521_CCR_MODE_SGPHY_TO_RGMAC          4
 171 #define YT8521_CCR_MODE_SGMAC_TO_RGPHY          5
 172 #define YT8521_CCR_MODE_UTP_TO_FIBER_AUTO       6
 173 #define YT8521_CCR_MODE_UTP_TO_FIBER_FORCE      7
 174
 175 /* 3 phy polling modes,poll mode combines utp and fiber mode*/
 176 #define YT8521_MODE_FIBER                       0x1
 177 #define YT8521_MODE_UTP                         0x2
 178 #define YT8521_MODE_POLL                        0x3
 179
 180 #define YT8521_RGMII_CONFIG1_REG                0xA003
 181
 182 /* TX Gig-E Delay is bits 3:0, default 0x1
 183  * TX Fast-E Delay is bits 7:4, default 0xf
 184  * RX Delay is bits 13:10, default 0x0
 185  * Delay = 150ps * N
 186  * On = 2250ps, off = 0ps
 187  */
 188 #define YT8521_RC1R_RX_DELAY_MASK               (0xF << 10)
 189 #define YT8521_RC1R_RX_DELAY_EN                 (0xF << 10)
 190 #define YT8521_RC1R_RX_DELAY_DIS                (0x0 << 10)
 191 #define YT8521_RC1R_FE_TX_DELAY_MASK            (0xF << 4)
 192 #define YT8521_RC1R_FE_TX_DELAY_EN              (0xF << 4)
 193 #define YT8521_RC1R_FE_TX_DELAY_DIS             (0x0 << 4)
 194 #define YT8521_RC1R_GE_TX_DELAY_MASK            (0xF << 0)
 195 #define YT8521_RC1R_GE_TX_DELAY_EN              (0xF << 0)
 196 #define YT8521_RC1R_GE_TX_DELAY_DIS             (0x0 << 0)
 197
 198 #define YTPHY_MISC_CONFIG_REG                   0xA006
 199 #define YTPHY_MCR_FIBER_SPEED_MASK              BIT(0)
 200 #define YTPHY_MCR_FIBER_1000BX                  (0x1 << 0)
 201 #define YTPHY_MCR_FIBER_100FX                   (0x0 << 0)
 202
 203 /* WOL MAC ADDR: MACADDR2(highest), MACADDR1(middle), MACADDR0(lowest) */
 204 #define YTPHY_WOL_MACADDR2_REG                  0xA007
 205 #define YTPHY_WOL_MACADDR1_REG                  0xA008
 206 #define YTPHY_WOL_MACADDR0_REG                  0xA009
 207
 208 #define YTPHY_WOL_CONFIG_REG                    0xA00A
 209 #define YTPHY_WCR_INTR_SEL                      BIT(6)
 210 #define YTPHY_WCR_ENABLE                        BIT(3)
 211
 212 /* 2b00 84ms
 213  * 2b01 168ms  *default*
 214  * 2b10 336ms
 215  * 2b11 672ms
 216  */
 217 #define YTPHY_WCR_PULSE_WIDTH_MASK              (BIT(2) | BIT(1))
 218 #define YTPHY_WCR_PULSE_WIDTH_672MS             (BIT(2) | BIT(1))
 219
 220 /* 1b0 Interrupt and WOL events is level triggered and active LOW  *default*
 221  * 1b1 Interrupt and WOL events is pulse triggered and active LOW
 222  */
 223 #define YTPHY_WCR_TYPE_PULSE                    BIT(0)
 224
 225 /* Extended Register  end */
 226
 227 struct yt8521_priv {
 228         /* combo_advertising is used for case of YT8521 in combo mode,
 229          * this means that yt8521 may work in utp or fiber mode which depends
 230          * on which media is connected (YT8521_RSSR_TO_BE_ARBITRATED).
 231          */
 232         __ETHTOOL_DECLARE_LINK_MODE_MASK(combo_advertising);
 233
 234         /* YT8521_MODE_FIBER / YT8521_MODE_UTP / YT8521_MODE_POLL*/
 235         u8 polling_mode;
 236         u8 strap_mode; /* 8 working modes  */
 237         /* current reg page of yt8521 phy:
 238          * YT8521_RSSR_UTP_SPACE
 239          * YT8521_RSSR_FIBER_SPACE
 240          * YT8521_RSSR_TO_BE_ARBITRATED
 241          */
 242         u8 reg_page;
 243 };
 244
 245 /**
 246  * ytphy_read_ext() - read a PHY's extended register
 247  * @phydev: a pointer to a &struct phy_device
 248  * @regnum: register number to read
 249  *
 250  * NOTE:The caller must have taken the MDIO bus lock.
 251  *
 252  * returns the value of regnum reg or negative error code
 253  */
 254 static int ytphy_read_ext(struct phy_device *phydev, u16 regnum)
 255 {
 256         int ret;
 257
 258         ret = __phy_write(phydev, YTPHY_PAGE_SELECT, regnum);
 259         if (ret < 0)
 260                 return ret;
 261
 262         return __phy_read(phydev, YTPHY_PAGE_DATA);
 263 }
 264
 265 /**
 266  * ytphy_read_ext_with_lock() - read a PHY's extended register
 267  * @phydev: a pointer to a &struct phy_device
 268  * @regnum: register number to read
 269  *
 270  * returns the value of regnum reg or negative error code
 271  */
 272 static int ytphy_read_ext_with_lock(struct phy_device *phydev, u16 regnum)
 273 {
 274         int ret;
 275
 276         phy_lock_mdio_bus(phydev);
 277         ret = ytphy_read_ext(phydev, regnum);
 278         phy_unlock_mdio_bus(phydev);
 279
 280         return ret;
 281 }
 282
 283 /**
 284  * ytphy_write_ext() - write a PHY's extended register
 285  * @phydev: a pointer to a &struct phy_device
 286  * @regnum: register number to write
 287  * @val: value to write to @regnum
 288  *
 289  * NOTE:The caller must have taken the MDIO bus lock.
 290  *
 291  * returns 0 or negative error code
 292  */
 293 static int ytphy_write_ext(struct phy_device *phydev, u16 regnum, u16 val)
 294 {
 295         int ret;
 296
 297         ret = __phy_write(phydev, YTPHY_PAGE_SELECT, regnum);
 298         if (ret < 0)
 299                 return ret;
 300
 301         return __phy_write(phydev, YTPHY_PAGE_DATA, val);
 302 }
 303
 304 /**
 305  * ytphy_write_ext_with_lock() - write a PHY's extended register
 306  * @phydev: a pointer to a &struct phy_device
 307  * @regnum: register number to write
 308  * @val: value to write to @regnum
 309  *
 310  * returns 0 or negative error code
 311  */
 312 static int ytphy_write_ext_with_lock(struct phy_device *phydev, u16 regnum,
 313                                      u16 val)
 314 {
 315         int ret;
 316
 317         phy_lock_mdio_bus(phydev);
 318         ret = ytphy_write_ext(phydev, regnum, val);
 319         phy_unlock_mdio_bus(phydev);
 320
 321         return ret;
 322 }
 323
 324 /**
 325  * ytphy_modify_ext() - bits modify a PHY's extended register
 326  * @phydev: a pointer to a &struct phy_device
 327  * @regnum: register number to write
 328  * @mask: bit mask of bits to clear
 329  * @set: bit mask of bits to set
 330  *
 331  * NOTE: Convenience function which allows a PHY's extended register to be
 332  * modified as new register value = (old register value & ~mask) | set.
 333  * The caller must have taken the MDIO bus lock.
 334  *
 335  * returns 0 or negative error code
 336  */
 337 static int ytphy_modify_ext(struct phy_device *phydev, u16 regnum, u16 mask,
 338                             u16 set)
 339 {
 340         int ret;
 341
 342         ret = __phy_write(phydev, YTPHY_PAGE_SELECT, regnum);
 343         if (ret < 0)
 344                 return ret;
 345
 346         return __phy_modify(phydev, YTPHY_PAGE_DATA, mask, set);
 347 }
 348
 349 /**
 350  * ytphy_modify_ext_with_lock() - bits modify a PHY's extended register
 351  * @phydev: a pointer to a &struct phy_device
 352  * @regnum: register number to write
 353  * @mask: bit mask of bits to clear
 354  * @set: bit mask of bits to set
 355  *
 356  * NOTE: Convenience function which allows a PHY's extended register to be
 357  * modified as new register value = (old register value & ~mask) | set.
 358  *
 359  * returns 0 or negative error code
 360  */
 361 static int ytphy_modify_ext_with_lock(struct phy_device *phydev, u16 regnum,
 362                                       u16 mask, u16 set)
 363 {
 364         int ret;
 365
 366         phy_lock_mdio_bus(phydev);
 367         ret = ytphy_modify_ext(phydev, regnum, mask, set);
 368         phy_unlock_mdio_bus(phydev);
 369
 370         return ret;
 371 }
 372
 373 /**
 374  * ytphy_get_wol() - report whether wake-on-lan is enabled
 375  * @phydev: a pointer to a &struct phy_device
 376  * @wol: a pointer to a &struct ethtool_wolinfo
 377  *
 378  * NOTE: YTPHY_WOL_CONFIG_REG is common ext reg.
 379  */
 380 static void ytphy_get_wol(struct phy_device *phydev,
 381                           struct ethtool_wolinfo *wol)
 382 {
 383         int wol_config;
 384
 385         wol->supported = WAKE_MAGIC;
 386         wol->wolopts = 0;
 387
 388         wol_config = ytphy_read_ext_with_lock(phydev, YTPHY_WOL_CONFIG_REG);
 389         if (wol_config < 0)
 390                 return;
 391
 392         if (wol_config & YTPHY_WCR_ENABLE)
 393                 wol->wolopts |= WAKE_MAGIC;
 394 }
 395
 396 /**
 397  * ytphy_set_wol() - turn wake-on-lan on or off
 398  * @phydev: a pointer to a &struct phy_device
 399  * @wol: a pointer to a &struct ethtool_wolinfo
 400  *
 401  * NOTE: YTPHY_WOL_CONFIG_REG, YTPHY_WOL_MACADDR2_REG, YTPHY_WOL_MACADDR1_REG
 402  * and YTPHY_WOL_MACADDR0_REG are common ext reg. The
 403  * YTPHY_INTERRUPT_ENABLE_REG of UTP is special, fiber also use this register.
 404  *
 405  * returns 0 or negative errno code
 406  */
 407 static int ytphy_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)
 408 {
 409         struct net_device *p_attached_dev;
 410         const u16 mac_addr_reg[] = {
 411                 YTPHY_WOL_MACADDR2_REG,
 412                 YTPHY_WOL_MACADDR1_REG,
 413                 YTPHY_WOL_MACADDR0_REG,
 414         };
 415         const u8 *mac_addr;
 416         int old_page;
 417         int ret = 0;
 418         u16 mask;
 419         u16 val;
 420         u8 i;
 421
 422         if (wol->wolopts & WAKE_MAGIC) {
 423                 p_attached_dev = phydev->attached_dev;
 424                 if (!p_attached_dev)
 425                         return -ENODEV;
 426
 427                 mac_addr = (const u8 *)p_attached_dev->dev_addr;
 428                 if (!is_valid_ether_addr(mac_addr))
 429                         return -EINVAL;
 430
 431                 /* lock mdio bus then switch to utp reg space */
 432                 old_page = phy_select_page(phydev, YT8521_RSSR_UTP_SPACE);
 433                 if (old_page < 0)
 434                         goto err_restore_page;
 435
 436                 /* Store the device address for the magic packet */
 437                 for (i = 0; i < 3; i++) {
 438                         ret = ytphy_write_ext(phydev, mac_addr_reg[i],
 439                                               ((mac_addr[i * 2] << 8)) |
 440                                                       (mac_addr[i * 2 + 1]));
 441                         if (ret < 0)
 442                                 goto err_restore_page;
 443                 }
 444
 445                 /* Enable WOL feature */
 446                 mask = YTPHY_WCR_PULSE_WIDTH_MASK | YTPHY_WCR_INTR_SEL;
 447                 val = YTPHY_WCR_ENABLE | YTPHY_WCR_INTR_SEL;
 448                 val |= YTPHY_WCR_TYPE_PULSE | YTPHY_WCR_PULSE_WIDTH_672MS;
 449                 ret = ytphy_modify_ext(phydev, YTPHY_WOL_CONFIG_REG, mask, val);
 450                 if (ret < 0)
 451                         goto err_restore_page;
 452
 453                 /* Enable WOL interrupt */
 454                 ret = __phy_modify(phydev, YTPHY_INTERRUPT_ENABLE_REG, 0,
 455                                    YTPHY_IER_WOL);
 456                 if (ret < 0)
 457                         goto err_restore_page;
 458
 459         } else {
 460                 old_page = phy_select_page(phydev, YT8521_RSSR_UTP_SPACE);
 461                 if (old_page < 0)
 462                         goto err_restore_page;
 463
 464                 /* Disable WOL feature */
 465                 mask = YTPHY_WCR_ENABLE | YTPHY_WCR_INTR_SEL;
 466                 ret = ytphy_modify_ext(phydev, YTPHY_WOL_CONFIG_REG, mask, 0);
 467
 468                 /* Disable WOL interrupt */
 469                 ret = __phy_modify(phydev, YTPHY_INTERRUPT_ENABLE_REG,
 470                                    YTPHY_IER_WOL, 0);
 471                 if (ret < 0)
 472                         goto err_restore_page;
 473         }
 474
 475 err_restore_page:
 476         return phy_restore_page(phydev, old_page, ret);
 477 }
 478
 479 static int yt8511_read_page(struct phy_device *phydev)
 480 {
 481         return __phy_read(phydev, YT8511_PAGE_SELECT);
 482 };
 483
 484 static int yt8511_write_page(struct phy_device *phydev, int page)
 485 {
 486         return __phy_write(phydev, YT8511_PAGE_SELECT, page);
 487 };
 488
 489 static int yt8511_config_init(struct phy_device *phydev)
 490 {
 491         int oldpage, ret = 0;
 492         unsigned int ge, fe;
 493
 494         oldpage = phy_select_page(phydev, YT8511_EXT_CLK_GATE);
 495         if (oldpage < 0)
 496                 goto err_restore_page;
 497
 498         /* set rgmii delay mode */
 499         switch (phydev->interface) {
 500         case PHY_INTERFACE_MODE_RGMII:
 501                 ge = YT8511_DELAY_GE_TX_DIS;
 502                 fe = YT8511_DELAY_FE_TX_DIS;
 503                 break;
 504         case PHY_INTERFACE_MODE_RGMII_RXID:
 505                 ge = YT8511_DELAY_RX | YT8511_DELAY_GE_TX_DIS;
 506                 fe = YT8511_DELAY_FE_TX_DIS;
 507                 break;
 508         case PHY_INTERFACE_MODE_RGMII_TXID:
 509                 ge = YT8511_DELAY_GE_TX_EN;
 510                 fe = YT8511_DELAY_FE_TX_EN;
 511                 break;
 512         case PHY_INTERFACE_MODE_RGMII_ID:
 513                 ge = YT8511_DELAY_RX | YT8511_DELAY_GE_TX_EN;
 514                 fe = YT8511_DELAY_FE_TX_EN;
 515                 break;
 516         default: /* do not support other modes */
 517                 ret = -EOPNOTSUPP;
 518                 goto err_restore_page;
 519         }
 520
 521         ret = __phy_modify(phydev, YT8511_PAGE, (YT8511_DELAY_RX | YT8511_DELAY_GE_TX_EN), ge);
 522         if (ret < 0)
 523                 goto err_restore_page;
 524
 525         /* set clock mode to 125mhz */
 526         ret = __phy_modify(phydev, YT8511_PAGE, 0, YT8511_CLK_125M);
 527         if (ret < 0)
 528                 goto err_restore_page;
 529
 530         /* fast ethernet delay is in a separate page */
 531         ret = __phy_write(phydev, YT8511_PAGE_SELECT, YT8511_EXT_DELAY_DRIVE);
 532         if (ret < 0)
 533                 goto err_restore_page;
 534
 535         ret = __phy_modify(phydev, YT8511_PAGE, YT8511_DELAY_FE_TX_EN, fe);
 536         if (ret < 0)
 537                 goto err_restore_page;
 538
 539         /* leave pll enabled in sleep */
 540         ret = __phy_write(phydev, YT8511_PAGE_SELECT, YT8511_EXT_SLEEP_CTRL);
 541         if (ret < 0)
 542                 goto err_restore_page;
 543
 544         ret = __phy_modify(phydev, YT8511_PAGE, 0, YT8511_PLLON_SLP);
 545         if (ret < 0)
 546                 goto err_restore_page;
 547
 548 err_restore_page:
 549         return phy_restore_page(phydev, oldpage, ret);
 550 }
 551
 552 /**
 553  * yt8521_read_page() - read reg page
 554  * @phydev: a pointer to a &struct phy_device
 555  *
 556  * returns current reg space of yt8521 (YT8521_RSSR_FIBER_SPACE/
 557  * YT8521_RSSR_UTP_SPACE) or negative errno code
 558  */
 559 static int yt8521_read_page(struct phy_device *phydev)
 560 {
 561         int old_page;
 562
 563         old_page = ytphy_read_ext(phydev, YT8521_REG_SPACE_SELECT_REG);
 564         if (old_page < 0)
 565                 return old_page;
 566
 567         if ((old_page & YT8521_RSSR_SPACE_MASK) == YT8521_RSSR_FIBER_SPACE)
 568                 return YT8521_RSSR_FIBER_SPACE;
 569
 570         return YT8521_RSSR_UTP_SPACE;
 571 };
 572
 573 /**
 574  * yt8521_write_page() - write reg page
 575  * @phydev: a pointer to a &struct phy_device
 576  * @page: The reg page(YT8521_RSSR_FIBER_SPACE/YT8521_RSSR_UTP_SPACE) to write.
 577  *
 578  * returns 0 or negative errno code
 579  */
 580 static int yt8521_write_page(struct phy_device *phydev, int page)
 581 {
 582         int mask = YT8521_RSSR_SPACE_MASK;
 583         int set;
 584
 585         if ((page & YT8521_RSSR_SPACE_MASK) == YT8521_RSSR_FIBER_SPACE)
 586                 set = YT8521_RSSR_FIBER_SPACE;
 587         else
 588                 set = YT8521_RSSR_UTP_SPACE;
 589
 590         return ytphy_modify_ext(phydev, YT8521_REG_SPACE_SELECT_REG, mask, set);
 591 };
 592
 593 /**
 594  * yt8521_probe() - read chip config then set suitable polling_mode
 595  * @phydev: a pointer to a &struct phy_device
 596  *
 597  * returns 0 or negative errno code
 598  */
 599 static int yt8521_probe(struct phy_device *phydev)
 600 {
 601         struct device *dev = &phydev->mdio.dev;
 602         struct yt8521_priv *priv;
 603         int chip_config;
 604         int ret;
 605
 606         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 607         if (!priv)
 608                 return -ENOMEM;
 609
 610         phydev->priv = priv;
 611
 612         chip_config = ytphy_read_ext_with_lock(phydev, YT8521_CHIP_CONFIG_REG);
 613         if (chip_config < 0)
 614                 return chip_config;
 615
 616         priv->strap_mode = chip_config & YT8521_CCR_MODE_SEL_MASK;
 617         switch (priv->strap_mode) {
 618         case YT8521_CCR_MODE_FIBER_TO_RGMII:
 619         case YT8521_CCR_MODE_SGPHY_TO_RGMAC:
 620         case YT8521_CCR_MODE_SGMAC_TO_RGPHY:
 621                 priv->polling_mode = YT8521_MODE_FIBER;
 622                 priv->reg_page = YT8521_RSSR_FIBER_SPACE;
 623                 phydev->port = PORT_FIBRE;
 624                 break;
 625         case YT8521_CCR_MODE_UTP_FIBER_TO_RGMII:
 626         case YT8521_CCR_MODE_UTP_TO_FIBER_AUTO:
 627         case YT8521_CCR_MODE_UTP_TO_FIBER_FORCE:
 628                 priv->polling_mode = YT8521_MODE_POLL;
 629                 priv->reg_page = YT8521_RSSR_TO_BE_ARBITRATED;
 630                 phydev->port = PORT_NONE;
 631                 break;
 632         case YT8521_CCR_MODE_UTP_TO_SGMII:
 633         case YT8521_CCR_MODE_UTP_TO_RGMII:
 634                 priv->polling_mode = YT8521_MODE_UTP;
 635                 priv->reg_page = YT8521_RSSR_UTP_SPACE;
 636                 phydev->port = PORT_TP;
 637                 break;
 638         }
 639         /* set default reg space */
 640         if (priv->reg_page != YT8521_RSSR_TO_BE_ARBITRATED) {
 641                 ret = ytphy_write_ext_with_lock(phydev,
 642                                                 YT8521_REG_SPACE_SELECT_REG,
 643                                                 priv->reg_page);
 644                 if (ret < 0)
 645                         return ret;
 646         }
 647
 648         return 0;
 649 }
 650
 651 /**
 652  * ytphy_utp_read_lpa() - read LPA then setup lp_advertising for utp
 653  * @phydev: a pointer to a &struct phy_device
 654  *
 655  * NOTE:The caller must have taken the MDIO bus lock.
 656  *
 657  * returns 0 or negative errno code
 658  */
 659 static int ytphy_utp_read_lpa(struct phy_device *phydev)
 660 {
 661         int lpa, lpagb;
 662
 663         if (phydev->autoneg == AUTONEG_ENABLE) {
 664                 if (!phydev->autoneg_complete) {
 665                         mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
 666                                                         0);
 667                         mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, 0);
 668                         return 0;
 669                 }
 670
 671                 if (phydev->is_gigabit_capable) {
 672                         lpagb = __phy_read(phydev, MII_STAT1000);
 673                         if (lpagb < 0)
 674                                 return lpagb;
 675
 676                         if (lpagb & LPA_1000MSFAIL) {
 677                                 int adv = __phy_read(phydev, MII_CTRL1000);
 678
 679                                 if (adv < 0)
 680                                         return adv;
 681
 682                                 if (adv & CTL1000_ENABLE_MASTER)
 683                                         phydev_err(phydev, "Master/Slave resolution failed, maybe conflicting manual settings?\n");
 684                                 else
 685                                         phydev_err(phydev, "Master/Slave resolution failed\n");
 686                                 return -ENOLINK;
 687                         }
 688
 689                         mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
 690                                                         lpagb);
 691                 }
 692
 693                 lpa = __phy_read(phydev, MII_LPA);
 694                 if (lpa < 0)
 695                         return lpa;
 696
 697                 mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, lpa);
 698         } else {
 699                 linkmode_zero(phydev->lp_advertising);
 700         }
 701
 702         return 0;
 703 }
 704
 705 /**
 706  * yt8521_adjust_status() - update speed and duplex to phydev. when in fiber
 707  * mode, adjust speed and duplex.
 708  * @phydev: a pointer to a &struct phy_device
 709  * @status: yt8521 status read from YTPHY_SPECIFIC_STATUS_REG
 710  * @is_utp: false(yt8521 work in fiber mode) or true(yt8521 work in utp mode)
 711  *
 712  * NOTE:The caller must have taken the MDIO bus lock.
 713  *
 714  * returns 0
 715  */
 716 static int yt8521_adjust_status(struct phy_device *phydev, int status,
 717                                 bool is_utp)
 718 {
 719         int speed_mode, duplex;
 720         int speed;
 721         int err;
 722         int lpa;
 723
 724         if (is_utp)
 725                 duplex = (status & YTPHY_SSR_DUPLEX) >> YTPHY_SSR_DUPLEX_OFFSET;
 726         else
 727                 duplex = DUPLEX_FULL;   /* for fiber, it always DUPLEX_FULL */
 728
 729         speed_mode = (status & YTPHY_SSR_SPEED_MODE_MASK) >>
 730                      YTPHY_SSR_SPEED_MODE_OFFSET;
 731
 732         switch (speed_mode) {
 733         case YTPHY_SSR_SPEED_10M:
 734                 if (is_utp)
 735                         speed = SPEED_10;
 736                 else
 737                         /* for fiber, it will never run here, default to
 738                          * SPEED_UNKNOWN
 739                          */
 740                         speed = SPEED_UNKNOWN;
 741                 break;
 742         case YTPHY_SSR_SPEED_100M:
 743                 speed = SPEED_100;
 744                 break;
 745         case YTPHY_SSR_SPEED_1000M:
 746                 speed = SPEED_1000;
 747                 break;
 748         default:
 749                 speed = SPEED_UNKNOWN;
 750                 break;
 751         }
 752
 753         phydev->speed = speed;
 754         phydev->duplex = duplex;
 755
 756         if (is_utp) {
 757                 err = ytphy_utp_read_lpa(phydev);
 758                 if (err < 0)
 759                         return err;
 760
 761                 phy_resolve_aneg_pause(phydev);
 762         } else {
 763                 lpa = __phy_read(phydev, MII_LPA);
 764                 if (lpa < 0)
 765                         return lpa;
 766
 767                 /* only support 1000baseX Full */
 768                 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
 769                                  phydev->lp_advertising, lpa & LPA_1000XFULL);
 770
 771                 if (!(lpa & YTPHY_FLPA_PAUSE)) {
 772                         phydev->pause = 0;
 773                         phydev->asym_pause = 0;
 774                 } else if ((lpa & YTPHY_FLPA_ASYM_PAUSE)) {
 775                         phydev->pause = 1;
 776                         phydev->asym_pause = 1;
 777                 } else {
 778                         phydev->pause = 1;
 779                         phydev->asym_pause = 0;
 780                 }
 781         }
 782
 783         return 0;
 784 }
 785
 786 /**
 787  * yt8521_read_status_paged() -  determines the speed and duplex of one page
 788  * @phydev: a pointer to a &struct phy_device
 789  * @page: The reg page(YT8521_RSSR_FIBER_SPACE/YT8521_RSSR_UTP_SPACE) to
 790  * operate.
 791  *
 792  * returns 1 (utp or fiber link),0 (no link) or negative errno code
 793  */
 794 static int yt8521_read_status_paged(struct phy_device *phydev, int page)
 795 {
 796         int fiber_latch_val;
 797         int fiber_curr_val;
 798         int old_page;
 799         int ret = 0;
 800         int status;
 801         int link;
 802
 803         linkmode_zero(phydev->lp_advertising);
 804         phydev->duplex = DUPLEX_UNKNOWN;
 805         phydev->speed = SPEED_UNKNOWN;
 806         phydev->asym_pause = 0;
 807         phydev->pause = 0;
 808
 809         /* YT8521 has two reg space (utp/fiber) for linkup with utp/fiber
 810          * respectively. but for utp/fiber combo mode, reg space should be
 811          * arbitrated based on media priority. by default, utp takes
 812          * priority. reg space should be properly set before read
 813          * YTPHY_SPECIFIC_STATUS_REG.
 814          */
 815
 816         page &= YT8521_RSSR_SPACE_MASK;
 817         old_page = phy_select_page(phydev, page);
 818         if (old_page < 0)
 819                 goto err_restore_page;
 820
 821         /* Read YTPHY_SPECIFIC_STATUS_REG, which indicates the speed and duplex
 822          * of the PHY is actually using.
 823          */
 824         ret = __phy_read(phydev, YTPHY_SPECIFIC_STATUS_REG);
 825         if (ret < 0)
 826                 goto err_restore_page;
 827
 828         status = ret;
 829         link = !!(status & YTPHY_SSR_LINK);
 830
 831         /* When PHY is in fiber mode, speed transferred from 1000Mbps to
 832          * 100Mbps,there is not link down from YTPHY_SPECIFIC_STATUS_REG, so
 833          * we need check MII_BMSR to identify such case.
 834          */
 835         if (page == YT8521_RSSR_FIBER_SPACE) {
 836                 ret = __phy_read(phydev, MII_BMSR);
 837                 if (ret < 0)
 838                         goto err_restore_page;
 839
 840                 fiber_latch_val = ret;
 841                 ret = __phy_read(phydev, MII_BMSR);
 842                 if (ret < 0)
 843                         goto err_restore_page;
 844
 845                 fiber_curr_val = ret;
 846                 if (link && fiber_latch_val != fiber_curr_val) {
 847                         link = 0;
 848                         phydev_info(phydev,
 849                                     "%s, fiber link down detect, latch = %04x, curr = %04x\n",
 850                                     __func__, fiber_latch_val, fiber_curr_val);
 851                 }
 852         } else {
 853                 /* Read autonegotiation status */
 854                 ret = __phy_read(phydev, MII_BMSR);
 855                 if (ret < 0)
 856                         goto err_restore_page;
 857
 858                 phydev->autoneg_complete = ret & BMSR_ANEGCOMPLETE ? 1 : 0;
 859         }
 860
 861         if (link) {
 862                 if (page == YT8521_RSSR_UTP_SPACE)
 863                         yt8521_adjust_status(phydev, status, true);
 864                 else
 865                         yt8521_adjust_status(phydev, status, false);
 866         }
 867         return phy_restore_page(phydev, old_page, link);
 868
 869 err_restore_page:
 870         return phy_restore_page(phydev, old_page, ret);
 871 }
 872
 873 /**
 874  * yt8521_read_status() -  determines the negotiated speed and duplex
 875  * @phydev: a pointer to a &struct phy_device
 876  *
 877  * returns 0 or negative errno code
 878  */
 879 static int yt8521_read_status(struct phy_device *phydev)
 880 {
 881         struct yt8521_priv *priv = phydev->priv;
 882         int link_fiber = 0;
 883         int link_utp;
 884         int link;
 885         int ret;
 886
 887         if (priv->reg_page != YT8521_RSSR_TO_BE_ARBITRATED) {
 888                 link = yt8521_read_status_paged(phydev, priv->reg_page);
 889                 if (link < 0)
 890                         return link;
 891         } else {
 892                 /* when page is YT8521_RSSR_TO_BE_ARBITRATED, arbitration is
 893                  * needed. by default, utp is higher priority.
 894                  */
 895
 896                 link_utp = yt8521_read_status_paged(phydev,
 897                                                     YT8521_RSSR_UTP_SPACE);
 898                 if (link_utp < 0)
 899                         return link_utp;
 900
 901                 if (!link_utp) {
 902                         link_fiber = yt8521_read_status_paged(phydev,
 903                                                               YT8521_RSSR_FIBER_SPACE);
 904                         if (link_fiber < 0)
 905                                 return link_fiber;
 906                 }
 907
 908                 link = link_utp || link_fiber;
 909         }
 910
 911         if (link) {
 912                 if (phydev->link == 0) {
 913                         /* arbitrate reg space based on linkup media type. */
 914                         if (priv->polling_mode == YT8521_MODE_POLL &&
 915                             priv->reg_page == YT8521_RSSR_TO_BE_ARBITRATED) {
 916                                 if (link_fiber)
 917                                         priv->reg_page =
 918                                                 YT8521_RSSR_FIBER_SPACE;
 919                                 else
 920                                         priv->reg_page = YT8521_RSSR_UTP_SPACE;
 921
 922                                 ret = ytphy_write_ext_with_lock(phydev,
 923                                                                 YT8521_REG_SPACE_SELECT_REG,
 924                                                                 priv->reg_page);
 925                                 if (ret < 0)
 926                                         return ret;
 927
 928                                 phydev->port = link_fiber ? PORT_FIBRE : PORT_TP;
 929
 930                                 phydev_info(phydev, "%s, link up, media: %s\n",
 931                                             __func__,
 932                                             (phydev->port == PORT_TP) ?
 933                                             "UTP" : "Fiber");
 934                         }
 935                 }
 936                 phydev->link = 1;
 937         } else {
 938                 if (phydev->link == 1) {
 939                         phydev_info(phydev, "%s, link down, media: %s\n",
 940                                     __func__, (phydev->port == PORT_TP) ?
 941                                     "UTP" : "Fiber");
 942
 943                         /* When in YT8521_MODE_POLL mode, need prepare for next
 944                          * arbitration.
 945                          */
 946                         if (priv->polling_mode == YT8521_MODE_POLL) {
 947                                 priv->reg_page = YT8521_RSSR_TO_BE_ARBITRATED;
 948                                 phydev->port = PORT_NONE;
 949                         }
 950                 }
 951
 952                 phydev->link = 0;
 953         }
 954
 955         return 0;
 956 }
 957
 958 /**
 959  * yt8521_modify_bmcr_paged - bits modify a PHY's BMCR register of one page
 960  * @phydev: the phy_device struct
 961  * @page: The reg page(YT8521_RSSR_FIBER_SPACE/YT8521_RSSR_UTP_SPACE) to operate
 962  * @mask: bit mask of bits to clear
 963  * @set: bit mask of bits to set
 964  *
 965  * NOTE: Convenience function which allows a PHY's BMCR register to be
 966  * modified as new register value = (old register value & ~mask) | set.
 967  * YT8521 has two space (utp/fiber) and three mode (utp/fiber/poll), each space
 968  * has MII_BMCR. poll mode combines utp and faber,so need do both.
 969  * If it is reset, it will wait for completion.
 970  *
 971  * returns 0 or negative errno code
 972  */
 973 static int yt8521_modify_bmcr_paged(struct phy_device *phydev, int page,
 974                                     u16 mask, u16 set)
 975 {
 976         int max_cnt = 500; /* the max wait time of reset ~ 500 ms */
 977         int old_page;
 978         int ret = 0;
 979
 980         old_page = phy_select_page(phydev, page & YT8521_RSSR_SPACE_MASK);
 981         if (old_page < 0)
 982                 goto err_restore_page;
 983
 984         ret = __phy_modify(phydev, MII_BMCR, mask, set);
 985         if (ret < 0)
 986                 goto err_restore_page;
 987
 988         /* If it is reset, need to wait for the reset to complete */
 989         if (set == BMCR_RESET) {
 990                 while (max_cnt--) {
 991                         usleep_range(1000, 1100);
 992                         ret = __phy_read(phydev, MII_BMCR);
 993                         if (ret < 0)
 994                                 goto err_restore_page;
 995
 996                         if (!(ret & BMCR_RESET))
 997                                 return phy_restore_page(phydev, old_page, 0);
 998                 }
 999         }
1000
1001 err_restore_page:
1002         return phy_restore_page(phydev, old_page, ret);
1003 }
1004
1005 /**
1006  * yt8521_modify_utp_fiber_bmcr - bits modify a PHY's BMCR register
1007  * @phydev: the phy_device struct
1008  * @mask: bit mask of bits to clear
1009  * @set: bit mask of bits to set
1010  *
1011  * NOTE: Convenience function which allows a PHY's BMCR register to be
1012  * modified as new register value = (old register value & ~mask) | set.
1013  * YT8521 has two space (utp/fiber) and three mode (utp/fiber/poll), each space
1014  * has MII_BMCR. poll mode combines utp and faber,so need do both.
1015  *
1016  * returns 0 or negative errno code
1017  */
1018 static int yt8521_modify_utp_fiber_bmcr(struct phy_device *phydev, u16 mask,
1019                                         u16 set)
1020 {
1021         struct yt8521_priv *priv = phydev->priv;
1022         int ret;
1023
1024         if (priv->reg_page != YT8521_RSSR_TO_BE_ARBITRATED) {
1025                 ret = yt8521_modify_bmcr_paged(phydev, priv->reg_page, mask,
1026                                                set);
1027                 if (ret < 0)
1028                         return ret;
1029         } else {
1030                 ret = yt8521_modify_bmcr_paged(phydev, YT8521_RSSR_UTP_SPACE,
1031                                                mask, set);
1032                 if (ret < 0)
1033                         return ret;
1034
1035                 ret = yt8521_modify_bmcr_paged(phydev, YT8521_RSSR_FIBER_SPACE,
1036                                                mask, set);
1037                 if (ret < 0)
1038                         return ret;
1039         }
1040         return 0;
1041 }
1042
1043 /**
1044  * yt8521_soft_reset() - called to issue a PHY software reset
1045  * @phydev: a pointer to a &struct phy_device
1046  *
1047  * returns 0 or negative errno code
1048  */
1049 static int yt8521_soft_reset(struct phy_device *phydev)
1050 {
1051         return yt8521_modify_utp_fiber_bmcr(phydev, 0, BMCR_RESET);
1052 }
1053
1054 /**
1055  * yt8521_suspend() - suspend the hardware
1056  * @phydev: a pointer to a &struct phy_device
1057  *
1058  * returns 0 or negative errno code
1059  */
1060 static int yt8521_suspend(struct phy_device *phydev)
1061 {
1062         int wol_config;
1063
1064         /* YTPHY_WOL_CONFIG_REG is common ext reg */
1065         wol_config = ytphy_read_ext_with_lock(phydev, YTPHY_WOL_CONFIG_REG);
1066         if (wol_config < 0)
1067                 return wol_config;
1068
1069         /* if wol enable, do nothing */
1070         if (wol_config & YTPHY_WCR_ENABLE)
1071                 return 0;
1072
1073         return yt8521_modify_utp_fiber_bmcr(phydev, 0, BMCR_PDOWN);
1074 }
1075
1076 /**
1077  * yt8521_resume() - resume the hardware
1078  * @phydev: a pointer to a &struct phy_device
1079  *
1080  * returns 0 or negative errno code
1081  */
1082 static int yt8521_resume(struct phy_device *phydev)
1083 {
1084         int ret;
1085         int wol_config;
1086
1087         /* disable auto sleep */
1088         ret = ytphy_modify_ext_with_lock(phydev,
1089                                          YT8521_EXTREG_SLEEP_CONTROL1_REG,
1090                                          YT8521_ESC1R_SLEEP_SW, 0);
1091         if (ret < 0)
1092                 return ret;
1093
1094         wol_config = ytphy_read_ext_with_lock(phydev, YTPHY_WOL_CONFIG_REG);
1095         if (wol_config < 0)
1096                 return wol_config;
1097
1098         /* if wol enable, do nothing */
1099         if (wol_config & YTPHY_WCR_ENABLE)
1100                 return 0;
1101
1102         return yt8521_modify_utp_fiber_bmcr(phydev, BMCR_PDOWN, 0);
1103 }
1104
1105 /**
1106  * yt8521_config_init() - called to initialize the PHY
1107  * @phydev: a pointer to a &struct phy_device
1108  *
1109  * returns 0 or negative errno code
1110  */
1111 static int yt8521_config_init(struct phy_device *phydev)
1112 {
1113         int old_page;
1114         int ret = 0;
1115         u16 val;
1116
1117         old_page = phy_select_page(phydev, YT8521_RSSR_UTP_SPACE);
1118         if (old_page < 0)
1119                 goto err_restore_page;
1120
1121         switch (phydev->interface) {
1122         case PHY_INTERFACE_MODE_RGMII:
1123                 val = YT8521_RC1R_GE_TX_DELAY_DIS | YT8521_RC1R_GE_TX_DELAY_DIS;
1124                 val |= YT8521_RC1R_RX_DELAY_DIS;
1125                 break;
1126         case PHY_INTERFACE_MODE_RGMII_RXID:
1127                 val = YT8521_RC1R_GE_TX_DELAY_DIS | YT8521_RC1R_GE_TX_DELAY_DIS;
1128                 val |= YT8521_RC1R_RX_DELAY_EN;
1129                 break;
1130         case PHY_INTERFACE_MODE_RGMII_TXID:
1131                 val = YT8521_RC1R_GE_TX_DELAY_EN | YT8521_RC1R_GE_TX_DELAY_EN;
1132                 val |= YT8521_RC1R_RX_DELAY_DIS;
1133                 break;
1134         case PHY_INTERFACE_MODE_RGMII_ID:
1135                 val = YT8521_RC1R_GE_TX_DELAY_EN | YT8521_RC1R_GE_TX_DELAY_EN;
1136                 val |= YT8521_RC1R_RX_DELAY_EN;
1137                 break;
1138         case PHY_INTERFACE_MODE_SGMII:
1139                 break;
1140         default: /* do not support other modes */
1141                 ret = -EOPNOTSUPP;
1142                 goto err_restore_page;
1143         }
1144
1145         /* set rgmii delay mode */
1146         if (phydev->interface != PHY_INTERFACE_MODE_SGMII) {
1147                 ret = ytphy_modify_ext(phydev, YT8521_RGMII_CONFIG1_REG,
1148                                        (YT8521_RC1R_RX_DELAY_MASK |
1149                                        YT8521_RC1R_FE_TX_DELAY_MASK |
1150                                        YT8521_RC1R_GE_TX_DELAY_MASK),
1151                                        val);
1152                 if (ret < 0)
1153                         goto err_restore_page;
1154
1155                 /* disable rx delay */
1156                 ret = ytphy_modify_ext(phydev, YT8521_CHIP_CONFIG_REG,
1157                                        YT8521_CCR_RXC_DLY_EN, 0);
1158                 if (ret < 0)
1159                         goto err_restore_page;
1160         }
1161
1162         /* disable auto sleep */
1163         ret = ytphy_modify_ext(phydev, YT8521_EXTREG_SLEEP_CONTROL1_REG,
1164                                YT8521_ESC1R_SLEEP_SW, 0);
1165         if (ret < 0)
1166                 goto err_restore_page;
1167
1168         /* enable RXC clock when no wire plug */
1169         ret = ytphy_modify_ext(phydev, YT8521_CLOCK_GATING_REG,
1170                                YT8521_CGR_RX_CLK_EN, 0);
1171         if (ret < 0)
1172                 goto err_restore_page;
1173
1174 err_restore_page:
1175         return phy_restore_page(phydev, old_page, ret);
1176 }
1177
1178 /**
1179  * yt8521_prepare_fiber_features() -  A small helper function that setup
1180  * fiber's features.
1181  * @phydev: a pointer to a &struct phy_device
1182  * @dst: a pointer to store fiber's features
1183  */
1184 static void yt8521_prepare_fiber_features(struct phy_device *phydev,
1185                                           unsigned long *dst)
1186 {
1187         linkmode_set_bit(ETHTOOL_LINK_MODE_100baseFX_Full_BIT, dst);
1188         linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT, dst);
1189         linkmode_set_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, dst);
1190         linkmode_set_bit(ETHTOOL_LINK_MODE_FIBRE_BIT, dst);
1191 }
1192
1193 /**
1194  * yt8521_fiber_setup_forced - configures/forces speed from @phydev
1195  * @phydev: target phy_device struct
1196  *
1197  * NOTE:The caller must have taken the MDIO bus lock.
1198  *
1199  * returns 0 or negative errno code
1200  */
1201 static int yt8521_fiber_setup_forced(struct phy_device *phydev)
1202 {
1203         u16 val;
1204         int ret;
1205
1206         if (phydev->speed == SPEED_1000)
1207                 val = YTPHY_MCR_FIBER_1000BX;
1208         else if (phydev->speed == SPEED_100)
1209                 val = YTPHY_MCR_FIBER_100FX;
1210         else
1211                 return -EINVAL;
1212
1213         ret =  __phy_modify(phydev, MII_BMCR, BMCR_ANENABLE, 0);
1214         if (ret < 0)
1215                 return ret;
1216
1217         /* disable Fiber auto sensing */
1218         ret =  ytphy_modify_ext(phydev, YT8521_LINK_TIMER_CFG2_REG,
1219                                 YT8521_LTCR_EN_AUTOSEN, 0);
1220         if (ret < 0)
1221                 return ret;
1222
1223         ret =  ytphy_modify_ext(phydev, YTPHY_MISC_CONFIG_REG,
1224                                 YTPHY_MCR_FIBER_SPEED_MASK, val);
1225         if (ret < 0)
1226                 return ret;
1227
1228         return ytphy_modify_ext(phydev, YT8521_CHIP_CONFIG_REG,
1229                                 YT8521_CCR_SW_RST, 0);
1230 }
1231
1232 /**
1233  * ytphy_check_and_restart_aneg - Enable and restart auto-negotiation
1234  * @phydev: target phy_device struct
1235  * @restart: whether aneg restart is requested
1236  *
1237  * NOTE:The caller must have taken the MDIO bus lock.
1238  *
1239  * returns 0 or negative errno code
1240  */
1241 static int ytphy_check_and_restart_aneg(struct phy_device *phydev, bool restart)
1242 {
1243         int ret;
1244
1245         if (!restart) {
1246                 /* Advertisement hasn't changed, but maybe aneg was never on to
1247                  * begin with?  Or maybe phy was isolated?
1248                  */
1249                 ret = __phy_read(phydev, MII_BMCR);
1250                 if (ret < 0)
1251                         return ret;
1252
1253                 if (!(ret & BMCR_ANENABLE) || (ret & BMCR_ISOLATE))
1254                         restart = true;
1255         }
1256         /* Enable and Restart Autonegotiation
1257          * Don't isolate the PHY if we're negotiating
1258          */
1259         if (restart)
1260                 return __phy_modify(phydev, MII_BMCR, BMCR_ISOLATE,
1261                                     BMCR_ANENABLE | BMCR_ANRESTART);
1262
1263         return 0;
1264 }
1265
1266 /**
1267  * yt8521_fiber_config_aneg - restart auto-negotiation or write
1268  * YTPHY_MISC_CONFIG_REG.
1269  * @phydev: target phy_device struct
1270  *
1271  * NOTE:The caller must have taken the MDIO bus lock.
1272  *
1273  * returns 0 or negative errno code
1274  */
1275 static int yt8521_fiber_config_aneg(struct phy_device *phydev)
1276 {
1277         int err, changed = 0;
1278         int bmcr;
1279         u16 adv;
1280
1281         if (phydev->autoneg != AUTONEG_ENABLE)
1282                 return yt8521_fiber_setup_forced(phydev);
1283
1284         /* enable Fiber auto sensing */
1285         err =  ytphy_modify_ext(phydev, YT8521_LINK_TIMER_CFG2_REG,
1286                                 0, YT8521_LTCR_EN_AUTOSEN);
1287         if (err < 0)
1288                 return err;
1289
1290         err =  ytphy_modify_ext(phydev, YT8521_CHIP_CONFIG_REG,
1291                                 YT8521_CCR_SW_RST, 0);
1292         if (err < 0)
1293                 return err;
1294
1295         bmcr = __phy_read(phydev, MII_BMCR);
1296         if (bmcr < 0)
1297                 return bmcr;
1298
1299         /* When it is coming from fiber forced mode, add bmcr power down
1300          * and power up to let aneg work fine.
1301          */
1302         if (!(bmcr & BMCR_ANENABLE)) {
1303                 __phy_modify(phydev, MII_BMCR, 0, BMCR_PDOWN);
1304                 usleep_range(1000, 1100);
1305                 __phy_modify(phydev, MII_BMCR, BMCR_PDOWN, 0);
1306         }
1307
1308         adv = linkmode_adv_to_mii_adv_x(phydev->advertising,
1309                                         ETHTOOL_LINK_MODE_1000baseX_Full_BIT);
1310
1311         /* Setup fiber advertisement */
1312         err = __phy_modify_changed(phydev, MII_ADVERTISE,
1313                                    ADVERTISE_1000XHALF | ADVERTISE_1000XFULL |
1314                                    ADVERTISE_1000XPAUSE |
1315                                    ADVERTISE_1000XPSE_ASYM,
1316                                    adv);
1317         if (err < 0)
1318                 return err;
1319
1320         if (err > 0)
1321                 changed = 1;
1322
1323         return ytphy_check_and_restart_aneg(phydev, changed);
1324 }
1325
1326 /**
1327  * ytphy_setup_master_slave
1328  * @phydev: target phy_device struct
1329  *
1330  * NOTE: The caller must have taken the MDIO bus lock.
1331  *
1332  * returns 0 or negative errno code
1333  */
1334 static int ytphy_setup_master_slave(struct phy_device *phydev)
1335 {
1336         u16 ctl = 0;
1337
1338         if (!phydev->is_gigabit_capable)
1339                 return 0;
1340
1341         switch (phydev->master_slave_set) {
1342         case MASTER_SLAVE_CFG_MASTER_PREFERRED:
1343                 ctl |= CTL1000_PREFER_MASTER;
1344                 break;
1345         case MASTER_SLAVE_CFG_SLAVE_PREFERRED:
1346                 break;
1347         case MASTER_SLAVE_CFG_MASTER_FORCE:
1348                 ctl |= CTL1000_AS_MASTER;
1349                 fallthrough;
1350         case MASTER_SLAVE_CFG_SLAVE_FORCE:
1351                 ctl |= CTL1000_ENABLE_MASTER;
1352                 break;
1353         case MASTER_SLAVE_CFG_UNKNOWN:
1354         case MASTER_SLAVE_CFG_UNSUPPORTED:
1355                 return 0;
1356         default:
1357                 phydev_warn(phydev, "Unsupported Master/Slave mode\n");
1358                 return -EOPNOTSUPP;
1359         }
1360
1361         return __phy_modify_changed(phydev, MII_CTRL1000,
1362                                     (CTL1000_ENABLE_MASTER | CTL1000_AS_MASTER |
1363                                     CTL1000_PREFER_MASTER), ctl);
1364 }
1365
1366 /**
1367  * ytphy_utp_config_advert - sanitize and advertise auto-negotiation parameters
1368  * @phydev: target phy_device struct
1369  *
1370  * NOTE: Writes MII_ADVERTISE with the appropriate values,
1371  * after sanitizing the values to make sure we only advertise
1372  * what is supported.  Returns < 0 on error, 0 if the PHY's advertisement
1373  * hasn't changed, and > 0 if it has changed.
1374  * The caller must have taken the MDIO bus lock.
1375  *
1376  * returns 0 or negative errno code
1377  */
1378 static int ytphy_utp_config_advert(struct phy_device *phydev)
1379 {
1380         int err, bmsr, changed = 0;
1381         u32 adv;
1382
1383         /* Only allow advertising what this PHY supports */
1384         linkmode_and(phydev->advertising, phydev->advertising,
1385                      phydev->supported);
1386
1387         adv = linkmode_adv_to_mii_adv_t(phydev->advertising);
1388
1389         /* Setup standard advertisement */
1390         err = __phy_modify_changed(phydev, MII_ADVERTISE,
1391                                    ADVERTISE_ALL | ADVERTISE_100BASE4 |
1392                                    ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM,
1393                                    adv);
1394         if (err < 0)
1395                 return err;
1396         if (err > 0)
1397                 changed = 1;
1398
1399         bmsr = __phy_read(phydev, MII_BMSR);
1400         if (bmsr < 0)
1401                 return bmsr;
1402
1403         /* Per 802.3-2008, Section 22.2.4.2.16 Extended status all
1404          * 1000Mbits/sec capable PHYs shall have the BMSR_ESTATEN bit set to a
1405          * logical 1.
1406          */
1407         if (!(bmsr & BMSR_ESTATEN))
1408                 return changed;
1409
1410         adv = linkmode_adv_to_mii_ctrl1000_t(phydev->advertising);
1411
1412         err = __phy_modify_changed(phydev, MII_CTRL1000,
1413                                    ADVERTISE_1000FULL | ADVERTISE_1000HALF,
1414                                    adv);
1415         if (err < 0)
1416                 return err;
1417         if (err > 0)
1418                 changed = 1;
1419
1420         return changed;
1421 }
1422
1423 /**
1424  * ytphy_utp_config_aneg - restart auto-negotiation or write BMCR
1425  * @phydev: target phy_device struct
1426  * @changed: whether autoneg is requested
1427  *
1428  * NOTE: If auto-negotiation is enabled, we configure the
1429  * advertising, and then restart auto-negotiation.  If it is not
1430  * enabled, then we write the BMCR.
1431  * The caller must have taken the MDIO bus lock.
1432  *
1433  * returns 0 or negative errno code
1434  */
1435 static int ytphy_utp_config_aneg(struct phy_device *phydev, bool changed)
1436 {
1437         int err;
1438         u16 ctl;
1439
1440         err = ytphy_setup_master_slave(phydev);
1441         if (err < 0)
1442                 return err;
1443         else if (err)
1444                 changed = true;
1445
1446         if (phydev->autoneg != AUTONEG_ENABLE) {
1447                 /* configures/forces speed/duplex from @phydev */
1448
1449                 ctl = mii_bmcr_encode_fixed(phydev->speed, phydev->duplex);
1450
1451                 return __phy_modify(phydev, MII_BMCR, ~(BMCR_LOOPBACK |
1452                                     BMCR_ISOLATE | BMCR_PDOWN), ctl);
1453         }
1454
1455         err = ytphy_utp_config_advert(phydev);
1456         if (err < 0) /* error */
1457                 return err;
1458         else if (err)
1459                 changed = true;
1460
1461         return ytphy_check_and_restart_aneg(phydev, changed);
1462 }
1463
1464 /**
1465  * yt8521_config_aneg_paged() - switch reg space then call genphy_config_aneg
1466  * of one page
1467  * @phydev: a pointer to a &struct phy_device
1468  * @page: The reg page(YT8521_RSSR_FIBER_SPACE/YT8521_RSSR_UTP_SPACE) to
1469  * operate.
1470  *
1471  * returns 0 or negative errno code
1472  */
1473 static int yt8521_config_aneg_paged(struct phy_device *phydev, int page)
1474 {
1475         __ETHTOOL_DECLARE_LINK_MODE_MASK(fiber_supported);
1476         struct yt8521_priv *priv = phydev->priv;
1477         int old_page;
1478         int ret = 0;
1479
1480         page &= YT8521_RSSR_SPACE_MASK;
1481
1482         old_page = phy_select_page(phydev, page);
1483         if (old_page < 0)
1484                 goto err_restore_page;
1485
1486         /* If reg_page is YT8521_RSSR_TO_BE_ARBITRATED,
1487          * phydev->advertising should be updated.
1488          */
1489         if (priv->reg_page == YT8521_RSSR_TO_BE_ARBITRATED) {
1490                 linkmode_zero(fiber_supported);
1491                 yt8521_prepare_fiber_features(phydev, fiber_supported);
1492
1493                 /* prepare fiber_supported, then setup advertising. */
1494                 if (page == YT8521_RSSR_FIBER_SPACE) {
1495                         linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
1496                                          fiber_supported);
1497                         linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
1498                                          fiber_supported);
1499                         linkmode_and(phydev->advertising,
1500                                      priv->combo_advertising, fiber_supported);
1501                 } else {
1502                         /* ETHTOOL_LINK_MODE_Autoneg_BIT is also used in utp */
1503                         linkmode_clear_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
1504                                            fiber_supported);
1505                         linkmode_andnot(phydev->advertising,
1506                                         priv->combo_advertising,
1507                                         fiber_supported);
1508                 }
1509         }
1510
1511         if (page == YT8521_RSSR_FIBER_SPACE)
1512                 ret = yt8521_fiber_config_aneg(phydev);
1513         else
1514                 ret = ytphy_utp_config_aneg(phydev, false);
1515
1516 err_restore_page:
1517         return phy_restore_page(phydev, old_page, ret);
1518 }
1519
1520 /**
1521  * yt8521_config_aneg() - change reg space then call yt8521_config_aneg_paged
1522  * @phydev: a pointer to a &struct phy_device
1523  *
1524  * returns 0 or negative errno code
1525  */
1526 static int yt8521_config_aneg(struct phy_device *phydev)
1527 {
1528         struct yt8521_priv *priv = phydev->priv;
1529         int ret;
1530
1531         if (priv->reg_page != YT8521_RSSR_TO_BE_ARBITRATED) {
1532                 ret = yt8521_config_aneg_paged(phydev, priv->reg_page);
1533                 if (ret < 0)
1534                         return ret;
1535         } else {
1536                 /* If reg_page is YT8521_RSSR_TO_BE_ARBITRATED,
1537                  * phydev->advertising need to be saved at first run.
1538                  * Because it contains the advertising which supported by both
1539                  * mac and yt8521(utp and fiber).
1540                  */
1541                 if (linkmode_empty(priv->combo_advertising)) {
1542                         linkmode_copy(priv->combo_advertising,
1543                                       phydev->advertising);
1544                 }
1545
1546                 ret = yt8521_config_aneg_paged(phydev, YT8521_RSSR_UTP_SPACE);
1547                 if (ret < 0)
1548                         return ret;
1549
1550                 ret = yt8521_config_aneg_paged(phydev, YT8521_RSSR_FIBER_SPACE);
1551                 if (ret < 0)
1552                         return ret;
1553
1554                 /* we don't known which will be link, so restore
1555                  * phydev->advertising as default value.
1556                  */
1557                 linkmode_copy(phydev->advertising, priv->combo_advertising);
1558         }
1559         return 0;
1560 }
1561
1562 /**
1563  * yt8521_aneg_done_paged() - determines the auto negotiation result of one
1564  * page.
1565  * @phydev: a pointer to a &struct phy_device
1566  * @page: The reg page(YT8521_RSSR_FIBER_SPACE/YT8521_RSSR_UTP_SPACE) to
1567  * operate.
1568  *
1569  * returns 0(no link)or 1(fiber or utp link) or negative errno code
1570  */
1571 static int yt8521_aneg_done_paged(struct phy_device *phydev, int page)
1572 {
1573         int old_page;
1574         int ret = 0;
1575         int link;
1576
1577         old_page = phy_select_page(phydev, page & YT8521_RSSR_SPACE_MASK);
1578         if (old_page < 0)
1579                 goto err_restore_page;
1580
1581         ret = __phy_read(phydev, YTPHY_SPECIFIC_STATUS_REG);
1582         if (ret < 0)
1583                 goto err_restore_page;
1584
1585         link = !!(ret & YTPHY_SSR_LINK);
1586         ret = link;
1587
1588 err_restore_page:
1589         return phy_restore_page(phydev, old_page, ret);
1590 }
1591
1592 /**
1593  * yt8521_aneg_done() - determines the auto negotiation result
1594  * @phydev: a pointer to a &struct phy_device
1595  *
1596  * returns 0(no link)or 1(fiber or utp link) or negative errno code
1597  */
1598 static int yt8521_aneg_done(struct phy_device *phydev)
1599 {
1600         struct yt8521_priv *priv = phydev->priv;
1601         int link_fiber = 0;
1602         int link_utp;
1603         int link;
1604
1605         if (priv->reg_page != YT8521_RSSR_TO_BE_ARBITRATED) {
1606                 link = yt8521_aneg_done_paged(phydev, priv->reg_page);
1607         } else {
1608                 link_utp = yt8521_aneg_done_paged(phydev,
1609                                                   YT8521_RSSR_UTP_SPACE);
1610                 if (link_utp < 0)
1611                         return link_utp;
1612
1613                 if (!link_utp) {
1614                         link_fiber = yt8521_aneg_done_paged(phydev,
1615                                                             YT8521_RSSR_FIBER_SPACE);
1616                         if (link_fiber < 0)
1617                                 return link_fiber;
1618                 }
1619                 link = link_fiber || link_utp;
1620                 phydev_info(phydev, "%s, link_fiber: %d, link_utp: %d\n",
1621                             __func__, link_fiber, link_utp);
1622         }
1623
1624         return link;
1625 }
1626
1627 /**
1628  * ytphy_utp_read_abilities - read PHY abilities from Clause 22 registers
1629  * @phydev: target phy_device struct
1630  *
1631  * NOTE: Reads the PHY's abilities and populates
1632  * phydev->supported accordingly.
1633  * The caller must have taken the MDIO bus lock.
1634  *
1635  * returns 0 or negative errno code
1636  */
1637 static int ytphy_utp_read_abilities(struct phy_device *phydev)
1638 {
1639         int val;
1640
1641         linkmode_set_bit_array(phy_basic_ports_array,
1642                                ARRAY_SIZE(phy_basic_ports_array),
1643                                phydev->supported);
1644
1645         val = __phy_read(phydev, MII_BMSR);
1646         if (val < 0)
1647                 return val;
1648
1649         linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, phydev->supported,
1650                          val & BMSR_ANEGCAPABLE);
1651
1652         linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, phydev->supported,
1653                          val & BMSR_100FULL);
1654         linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, phydev->supported,
1655                          val & BMSR_100HALF);
1656         linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, phydev->supported,
1657                          val & BMSR_10FULL);
1658         linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, phydev->supported,
1659                          val & BMSR_10HALF);
1660
1661         if (val & BMSR_ESTATEN) {
1662                 val = __phy_read(phydev, MII_ESTATUS);
1663                 if (val < 0)
1664                         return val;
1665
1666                 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
1667                                  phydev->supported, val & ESTATUS_1000_TFULL);
1668                 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
1669                                  phydev->supported, val & ESTATUS_1000_THALF);
1670                 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
1671                                  phydev->supported, val & ESTATUS_1000_XFULL);
1672         }
1673
1674         return 0;
1675 }
1676
1677 /**
1678  * yt8521_get_features_paged() -  read supported link modes for one page
1679  * @phydev: a pointer to a &struct phy_device
1680  * @page: The reg page(YT8521_RSSR_FIBER_SPACE/YT8521_RSSR_UTP_SPACE) to
1681  * operate.
1682  *
1683  * returns 0 or negative errno code
1684  */
1685 static int yt8521_get_features_paged(struct phy_device *phydev, int page)
1686 {
1687         int old_page;
1688         int ret = 0;
1689
1690         page &= YT8521_RSSR_SPACE_MASK;
1691         old_page = phy_select_page(phydev, page);
1692         if (old_page < 0)
1693                 goto err_restore_page;
1694
1695         if (page == YT8521_RSSR_FIBER_SPACE) {
1696                 linkmode_zero(phydev->supported);
1697                 yt8521_prepare_fiber_features(phydev, phydev->supported);
1698         } else {
1699                 ret = ytphy_utp_read_abilities(phydev);
1700                 if (ret < 0)
1701                         goto err_restore_page;
1702         }
1703
1704 err_restore_page:
1705         return phy_restore_page(phydev, old_page, ret);
1706 }
1707
1708 /**
1709  * yt8521_get_features - switch reg space then call yt8521_get_features_paged
1710  * @phydev: target phy_device struct
1711  *
1712  * returns 0 or negative errno code
1713  */
1714 static int yt8521_get_features(struct phy_device *phydev)
1715 {
1716         struct yt8521_priv *priv = phydev->priv;
1717         int ret;
1718
1719         if (priv->reg_page != YT8521_RSSR_TO_BE_ARBITRATED) {
1720                 ret = yt8521_get_features_paged(phydev, priv->reg_page);
1721         } else {
1722                 ret = yt8521_get_features_paged(phydev,
1723                                                 YT8521_RSSR_UTP_SPACE);
1724                 if (ret < 0)
1725                         return ret;
1726
1727                 /* add fiber's features to phydev->supported */
1728                 yt8521_prepare_fiber_features(phydev, phydev->supported);
1729         }
1730         return ret;
1731 }
1732
1733 static struct phy_driver motorcomm_phy_drvs[] = {
1734         {
1735                 PHY_ID_MATCH_EXACT(PHY_ID_YT8511),
1736                 .name           = "YT8511 Gigabit Ethernet",
1737                 .config_init    = yt8511_config_init,
1738                 .suspend        = genphy_suspend,
1739                 .resume         = genphy_resume,
1740                 .read_page      = yt8511_read_page,
1741                 .write_page     = yt8511_write_page,
1742         },
1743         {
1744                 PHY_ID_MATCH_EXACT(PHY_ID_YT8521),
1745                 .name           = "YT8521 Gigabit Ethernet",
1746                 .get_features   = yt8521_get_features,
1747                 .probe          = yt8521_probe,
1748                 .read_page      = yt8521_read_page,
1749                 .write_page     = yt8521_write_page,
1750                 .get_wol        = ytphy_get_wol,
1751                 .set_wol        = ytphy_set_wol,
1752                 .config_aneg    = yt8521_config_aneg,
1753                 .aneg_done      = yt8521_aneg_done,
1754                 .config_init    = yt8521_config_init,
1755                 .read_status    = yt8521_read_status,
1756                 .soft_reset     = yt8521_soft_reset,
1757                 .suspend        = yt8521_suspend,
1758                 .resume         = yt8521_resume,
1759         },
1760 };
1761
1762 module_phy_driver(motorcomm_phy_drvs);
1763
1764 MODULE_DESCRIPTION("Motorcomm 8511/8521 PHY driver");
1765 MODULE_AUTHOR("Peter Geis");
1766 MODULE_AUTHOR("Frank");
1767 MODULE_LICENSE("GPL");
1768
1769 static const struct mdio_device_id __maybe_unused motorcomm_tbl[] = {
1770         { PHY_ID_MATCH_EXACT(PHY_ID_YT8511) },
1771         { PHY_ID_MATCH_EXACT(PHY_ID_YT8521) },
1772         { /* sentinal */ }
1773 };
1774
1775 MODULE_DEVICE_TABLE(mdio, motorcomm_tbl);