drivers/net/pcs/pcs-xpcs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2020 Synopsys, Inc. and/or its affiliates.
   4  * Synopsys DesignWare XPCS helpers
   5  *
   6  * Author: Jose Abreu <Jose.Abreu@synopsys.com>
   7  */
   8
   9 #include <linux/delay.h>
  10 #include <linux/pcs/pcs-xpcs.h>
  11 #include <linux/mdio.h>
  12 #include <linux/phylink.h>
  13 #include <linux/workqueue.h>
  14
  15 #define SYNOPSYS_XPCS_ID                0x7996ced0
  16 #define SYNOPSYS_XPCS_MASK              0xffffffff
  17
  18 /* Vendor regs access */
  19 #define DW_VENDOR                       BIT(15)
  20
  21 /* VR_XS_PCS */
  22 #define DW_USXGMII_RST                  BIT(10)
  23 #define DW_USXGMII_EN                   BIT(9)
  24 #define DW_VR_XS_PCS_DIG_STS            0x0010
  25 #define DW_RXFIFO_ERR                   GENMASK(6, 5)
  26
  27 /* SR_MII */
  28 #define DW_USXGMII_FULL                 BIT(8)
  29 #define DW_USXGMII_SS_MASK              (BIT(13) | BIT(6) | BIT(5))
  30 #define DW_USXGMII_10000                (BIT(13) | BIT(6))
  31 #define DW_USXGMII_5000                 (BIT(13) | BIT(5))
  32 #define DW_USXGMII_2500                 (BIT(5))
  33 #define DW_USXGMII_1000                 (BIT(6))
  34 #define DW_USXGMII_100                  (BIT(13))
  35 #define DW_USXGMII_10                   (0)
  36
  37 /* SR_AN */
  38 #define DW_SR_AN_ADV1                   0x10
  39 #define DW_SR_AN_ADV2                   0x11
  40 #define DW_SR_AN_ADV3                   0x12
  41 #define DW_SR_AN_LP_ABL1                0x13
  42 #define DW_SR_AN_LP_ABL2                0x14
  43 #define DW_SR_AN_LP_ABL3                0x15
  44
  45 /* Clause 73 Defines */
  46 /* AN_LP_ABL1 */
  47 #define DW_C73_PAUSE                    BIT(10)
  48 #define DW_C73_ASYM_PAUSE               BIT(11)
  49 #define DW_C73_AN_ADV_SF                0x1
  50 /* AN_LP_ABL2 */
  51 #define DW_C73_1000KX                   BIT(5)
  52 #define DW_C73_10000KX4                 BIT(6)
  53 #define DW_C73_10000KR                  BIT(7)
  54 /* AN_LP_ABL3 */
  55 #define DW_C73_2500KX                   BIT(0)
  56 #define DW_C73_5000KR                   BIT(1)
  57
  58 /* Clause 37 Defines */
  59 /* VR MII MMD registers offsets */
  60 #define DW_VR_MII_DIG_CTRL1             0x8000
  61 #define DW_VR_MII_AN_CTRL               0x8001
  62 #define DW_VR_MII_AN_INTR_STS           0x8002
  63 /* EEE Mode Control Register */
  64 #define DW_VR_MII_EEE_MCTRL0            0x8006
  65 #define DW_VR_MII_EEE_MCTRL1            0x800b
  66
  67 /* VR_MII_DIG_CTRL1 */
  68 #define DW_VR_MII_DIG_CTRL1_MAC_AUTO_SW         BIT(9)
  69
  70 /* VR_MII_AN_CTRL */
  71 #define DW_VR_MII_AN_CTRL_TX_CONFIG_SHIFT       3
  72 #define DW_VR_MII_TX_CONFIG_MASK                BIT(3)
  73 #define DW_VR_MII_TX_CONFIG_PHY_SIDE_SGMII      0x1
  74 #define DW_VR_MII_TX_CONFIG_MAC_SIDE_SGMII      0x0
  75 #define DW_VR_MII_AN_CTRL_PCS_MODE_SHIFT        1
  76 #define DW_VR_MII_PCS_MODE_MASK                 GENMASK(2, 1)
  77 #define DW_VR_MII_PCS_MODE_C37_1000BASEX        0x0
  78 #define DW_VR_MII_PCS_MODE_C37_SGMII            0x2
  79
  80 /* VR_MII_AN_INTR_STS */
  81 #define DW_VR_MII_AN_STS_C37_ANSGM_FD           BIT(1)
  82 #define DW_VR_MII_AN_STS_C37_ANSGM_SP_SHIFT     2
  83 #define DW_VR_MII_AN_STS_C37_ANSGM_SP           GENMASK(3, 2)
  84 #define DW_VR_MII_C37_ANSGM_SP_10               0x0
  85 #define DW_VR_MII_C37_ANSGM_SP_100              0x1
  86 #define DW_VR_MII_C37_ANSGM_SP_1000             0x2
  87 #define DW_VR_MII_C37_ANSGM_SP_LNKSTS           BIT(4)
  88
  89 /* VR MII EEE Control 0 defines */
  90 #define DW_VR_MII_EEE_LTX_EN            BIT(0)  /* LPI Tx Enable */
  91 #define DW_VR_MII_EEE_LRX_EN            BIT(1)  /* LPI Rx Enable */
  92 #define DW_VR_MII_EEE_TX_QUIET_EN               BIT(2)  /* Tx Quiet Enable */
  93 #define DW_VR_MII_EEE_RX_QUIET_EN               BIT(3)  /* Rx Quiet Enable */
  94 #define DW_VR_MII_EEE_TX_EN_CTRL                BIT(4)  /* Tx Control Enable */
  95 #define DW_VR_MII_EEE_RX_EN_CTRL                BIT(7)  /* Rx Control Enable */
  96
  97 #define DW_VR_MII_EEE_MULT_FACT_100NS_SHIFT     8
  98 #define DW_VR_MII_EEE_MULT_FACT_100NS           GENMASK(11, 8)
  99
 100 /* VR MII EEE Control 1 defines */
 101 #define DW_VR_MII_EEE_TRN_LPI           BIT(0)  /* Transparent Mode Enable */
 102
 103 static const int xpcs_usxgmii_features[] = {
 104         ETHTOOL_LINK_MODE_Pause_BIT,
 105         ETHTOOL_LINK_MODE_Asym_Pause_BIT,
 106         ETHTOOL_LINK_MODE_Autoneg_BIT,
 107         ETHTOOL_LINK_MODE_1000baseKX_Full_BIT,
 108         ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT,
 109         ETHTOOL_LINK_MODE_10000baseKR_Full_BIT,
 110         ETHTOOL_LINK_MODE_2500baseX_Full_BIT,
 111         __ETHTOOL_LINK_MODE_MASK_NBITS,
 112 };
 113
 114 static const int xpcs_10gkr_features[] = {
 115         ETHTOOL_LINK_MODE_Pause_BIT,
 116         ETHTOOL_LINK_MODE_Asym_Pause_BIT,
 117         ETHTOOL_LINK_MODE_10000baseKR_Full_BIT,
 118         __ETHTOOL_LINK_MODE_MASK_NBITS,
 119 };
 120
 121 static const int xpcs_xlgmii_features[] = {
 122         ETHTOOL_LINK_MODE_Pause_BIT,
 123         ETHTOOL_LINK_MODE_Asym_Pause_BIT,
 124         ETHTOOL_LINK_MODE_25000baseCR_Full_BIT,
 125         ETHTOOL_LINK_MODE_25000baseKR_Full_BIT,
 126         ETHTOOL_LINK_MODE_25000baseSR_Full_BIT,
 127         ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT,
 128         ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT,
 129         ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT,
 130         ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT,
 131         ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT,
 132         ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT,
 133         ETHTOOL_LINK_MODE_50000baseSR2_Full_BIT,
 134         ETHTOOL_LINK_MODE_50000baseKR_Full_BIT,
 135         ETHTOOL_LINK_MODE_50000baseSR_Full_BIT,
 136         ETHTOOL_LINK_MODE_50000baseCR_Full_BIT,
 137         ETHTOOL_LINK_MODE_50000baseLR_ER_FR_Full_BIT,
 138         ETHTOOL_LINK_MODE_50000baseDR_Full_BIT,
 139         ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT,
 140         ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT,
 141         ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT,
 142         ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT,
 143         ETHTOOL_LINK_MODE_100000baseKR2_Full_BIT,
 144         ETHTOOL_LINK_MODE_100000baseSR2_Full_BIT,
 145         ETHTOOL_LINK_MODE_100000baseCR2_Full_BIT,
 146         ETHTOOL_LINK_MODE_100000baseLR2_ER2_FR2_Full_BIT,
 147         ETHTOOL_LINK_MODE_100000baseDR2_Full_BIT,
 148         __ETHTOOL_LINK_MODE_MASK_NBITS,
 149 };
 150
 151 static const int xpcs_sgmii_features[] = {
 152         ETHTOOL_LINK_MODE_10baseT_Half_BIT,
 153         ETHTOOL_LINK_MODE_10baseT_Full_BIT,
 154         ETHTOOL_LINK_MODE_100baseT_Half_BIT,
 155         ETHTOOL_LINK_MODE_100baseT_Full_BIT,
 156         ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
 157         ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
 158         __ETHTOOL_LINK_MODE_MASK_NBITS,
 159 };
 160
 161 static const phy_interface_t xpcs_usxgmii_interfaces[] = {
 162         PHY_INTERFACE_MODE_USXGMII,
 163 };
 164
 165 static const phy_interface_t xpcs_10gkr_interfaces[] = {
 166         PHY_INTERFACE_MODE_10GKR,
 167 };
 168
 169 static const phy_interface_t xpcs_xlgmii_interfaces[] = {
 170         PHY_INTERFACE_MODE_XLGMII,
 171 };
 172
 173 static const phy_interface_t xpcs_sgmii_interfaces[] = {
 174         PHY_INTERFACE_MODE_SGMII,
 175 };
 176
 177 enum {
 178         DW_XPCS_USXGMII,
 179         DW_XPCS_10GKR,
 180         DW_XPCS_XLGMII,
 181         DW_XPCS_SGMII,
 182         DW_XPCS_INTERFACE_MAX,
 183 };
 184
 185 struct xpcs_compat {
 186         const int *supported;
 187         const phy_interface_t *interface;
 188         int num_interfaces;
 189         int an_mode;
 190 };
 191
 192 struct xpcs_id {
 193         u32 id;
 194         u32 mask;
 195         const struct xpcs_compat *compat;
 196 };
 197
 198 static const struct xpcs_compat *xpcs_find_compat(const struct xpcs_id *id,
 199                                                   phy_interface_t interface)
 200 {
 201         int i, j;
 202
 203         for (i = 0; i < DW_XPCS_INTERFACE_MAX; i++) {
 204                 const struct xpcs_compat *compat = &id->compat[i];
 205
 206                 for (j = 0; j < compat->num_interfaces; j++)
 207                         if (compat->interface[j] == interface)
 208                                 return compat;
 209         }
 210
 211         return NULL;
 212 }
 213
 214 int xpcs_get_an_mode(struct mdio_xpcs_args *xpcs, phy_interface_t interface)
 215 {
 216         const struct xpcs_compat *compat;
 217
 218         compat = xpcs_find_compat(xpcs->id, interface);
 219         if (!compat)
 220                 return -ENODEV;
 221
 222         return compat->an_mode;
 223 }
 224 EXPORT_SYMBOL_GPL(xpcs_get_an_mode);
 225
 226 static bool __xpcs_linkmode_supported(const struct xpcs_compat *compat,
 227                                       enum ethtool_link_mode_bit_indices linkmode)
 228 {
 229         int i;
 230
 231         for (i = 0; compat->supported[i] != __ETHTOOL_LINK_MODE_MASK_NBITS; i++)
 232                 if (compat->supported[i] == linkmode)
 233                         return true;
 234
 235         return false;
 236 }
 237
 238 #define xpcs_linkmode_supported(compat, mode) \
 239         __xpcs_linkmode_supported(compat, ETHTOOL_LINK_MODE_ ## mode ## _BIT)
 240
 241 static int xpcs_read(struct mdio_xpcs_args *xpcs, int dev, u32 reg)
 242 {
 243         u32 reg_addr = MII_ADDR_C45 | dev << 16 | reg;
 244
 245         return mdiobus_read(xpcs->bus, xpcs->addr, reg_addr);
 246 }
 247
 248 static int xpcs_write(struct mdio_xpcs_args *xpcs, int dev, u32 reg, u16 val)
 249 {
 250         u32 reg_addr = MII_ADDR_C45 | dev << 16 | reg;
 251
 252         return mdiobus_write(xpcs->bus, xpcs->addr, reg_addr, val);
 253 }
 254
 255 static int xpcs_read_vendor(struct mdio_xpcs_args *xpcs, int dev, u32 reg)
 256 {
 257         return xpcs_read(xpcs, dev, DW_VENDOR | reg);
 258 }
 259
 260 static int xpcs_write_vendor(struct mdio_xpcs_args *xpcs, int dev, int reg,
 261                              u16 val)
 262 {
 263         return xpcs_write(xpcs, dev, DW_VENDOR | reg, val);
 264 }
 265
 266 static int xpcs_read_vpcs(struct mdio_xpcs_args *xpcs, int reg)
 267 {
 268         return xpcs_read_vendor(xpcs, MDIO_MMD_PCS, reg);
 269 }
 270
 271 static int xpcs_write_vpcs(struct mdio_xpcs_args *xpcs, int reg, u16 val)
 272 {
 273         return xpcs_write_vendor(xpcs, MDIO_MMD_PCS, reg, val);
 274 }
 275
 276 static int xpcs_poll_reset(struct mdio_xpcs_args *xpcs, int dev)
 277 {
 278         /* Poll until the reset bit clears (50ms per retry == 0.6 sec) */
 279         unsigned int retries = 12;
 280         int ret;
 281
 282         do {
 283                 msleep(50);
 284                 ret = xpcs_read(xpcs, dev, MDIO_CTRL1);
 285                 if (ret < 0)
 286                         return ret;
 287         } while (ret & MDIO_CTRL1_RESET && --retries);
 288
 289         return (ret & MDIO_CTRL1_RESET) ? -ETIMEDOUT : 0;
 290 }
 291
 292 static int xpcs_soft_reset(struct mdio_xpcs_args *xpcs,
 293                            const struct xpcs_compat *compat)
 294 {
 295         int ret, dev;
 296
 297         switch (compat->an_mode) {
 298         case DW_AN_C73:
 299                 dev = MDIO_MMD_PCS;
 300                 break;
 301         case DW_AN_C37_SGMII:
 302                 dev = MDIO_MMD_VEND2;
 303                 break;
 304         default:
 305                 return -1;
 306         }
 307
 308         ret = xpcs_write(xpcs, dev, MDIO_CTRL1, MDIO_CTRL1_RESET);
 309         if (ret < 0)
 310                 return ret;
 311
 312         return xpcs_poll_reset(xpcs, dev);
 313 }
 314
 315 #define xpcs_warn(__xpcs, __state, __args...) \
 316 ({ \
 317         if ((__state)->link) \
 318                 dev_warn(&(__xpcs)->bus->dev, ##__args); \
 319 })
 320
 321 static int xpcs_read_fault_c73(struct mdio_xpcs_args *xpcs,
 322                                struct phylink_link_state *state)
 323 {
 324         int ret;
 325
 326         ret = xpcs_read(xpcs, MDIO_MMD_PCS, MDIO_STAT1);
 327         if (ret < 0)
 328                 return ret;
 329
 330         if (ret & MDIO_STAT1_FAULT) {
 331                 xpcs_warn(xpcs, state, "Link fault condition detected!\n");
 332                 return -EFAULT;
 333         }
 334
 335         ret = xpcs_read(xpcs, MDIO_MMD_PCS, MDIO_STAT2);
 336         if (ret < 0)
 337                 return ret;
 338
 339         if (ret & MDIO_STAT2_RXFAULT)
 340                 xpcs_warn(xpcs, state, "Receiver fault detected!\n");
 341         if (ret & MDIO_STAT2_TXFAULT)
 342                 xpcs_warn(xpcs, state, "Transmitter fault detected!\n");
 343
 344         ret = xpcs_read_vendor(xpcs, MDIO_MMD_PCS, DW_VR_XS_PCS_DIG_STS);
 345         if (ret < 0)
 346                 return ret;
 347
 348         if (ret & DW_RXFIFO_ERR) {
 349                 xpcs_warn(xpcs, state, "FIFO fault condition detected!\n");
 350                 return -EFAULT;
 351         }
 352
 353         ret = xpcs_read(xpcs, MDIO_MMD_PCS, MDIO_PCS_10GBRT_STAT1);
 354         if (ret < 0)
 355                 return ret;
 356
 357         if (!(ret & MDIO_PCS_10GBRT_STAT1_BLKLK))
 358                 xpcs_warn(xpcs, state, "Link is not locked!\n");
 359
 360         ret = xpcs_read(xpcs, MDIO_MMD_PCS, MDIO_PCS_10GBRT_STAT2);
 361         if (ret < 0)
 362                 return ret;
 363
 364         if (ret & MDIO_PCS_10GBRT_STAT2_ERR) {
 365                 xpcs_warn(xpcs, state, "Link has errors!\n");
 366                 return -EFAULT;
 367         }
 368
 369         return 0;
 370 }
 371
 372 static int xpcs_read_link_c73(struct mdio_xpcs_args *xpcs, bool an)
 373 {
 374         bool link = true;
 375         int ret;
 376
 377         ret = xpcs_read(xpcs, MDIO_MMD_PCS, MDIO_STAT1);
 378         if (ret < 0)
 379                 return ret;
 380
 381         if (!(ret & MDIO_STAT1_LSTATUS))
 382                 link = false;
 383
 384         if (an) {
 385                 ret = xpcs_read(xpcs, MDIO_MMD_AN, MDIO_STAT1);
 386                 if (ret < 0)
 387                         return ret;
 388
 389                 if (!(ret & MDIO_STAT1_LSTATUS))
 390                         link = false;
 391         }
 392
 393         return link;
 394 }
 395
 396 static int xpcs_get_max_usxgmii_speed(const unsigned long *supported)
 397 {
 398         int max = SPEED_UNKNOWN;
 399
 400         if (phylink_test(supported, 1000baseKX_Full))
 401                 max = SPEED_1000;
 402         if (phylink_test(supported, 2500baseX_Full))
 403                 max = SPEED_2500;
 404         if (phylink_test(supported, 10000baseKX4_Full))
 405                 max = SPEED_10000;
 406         if (phylink_test(supported, 10000baseKR_Full))
 407                 max = SPEED_10000;
 408
 409         return max;
 410 }
 411
 412 static int xpcs_config_usxgmii(struct mdio_xpcs_args *xpcs, int speed)
 413 {
 414         int ret, speed_sel;
 415
 416         switch (speed) {
 417         case SPEED_10:
 418                 speed_sel = DW_USXGMII_10;
 419                 break;
 420         case SPEED_100:
 421                 speed_sel = DW_USXGMII_100;
 422                 break;
 423         case SPEED_1000:
 424                 speed_sel = DW_USXGMII_1000;
 425                 break;
 426         case SPEED_2500:
 427                 speed_sel = DW_USXGMII_2500;
 428                 break;
 429         case SPEED_5000:
 430                 speed_sel = DW_USXGMII_5000;
 431                 break;
 432         case SPEED_10000:
 433                 speed_sel = DW_USXGMII_10000;
 434                 break;
 435         default:
 436                 /* Nothing to do here */
 437                 return -EINVAL;
 438         }
 439
 440         ret = xpcs_read_vpcs(xpcs, MDIO_CTRL1);
 441         if (ret < 0)
 442                 return ret;
 443
 444         ret = xpcs_write_vpcs(xpcs, MDIO_CTRL1, ret | DW_USXGMII_EN);
 445         if (ret < 0)
 446                 return ret;
 447
 448         ret = xpcs_read(xpcs, MDIO_MMD_VEND2, MDIO_CTRL1);
 449         if (ret < 0)
 450                 return ret;
 451
 452         ret &= ~DW_USXGMII_SS_MASK;
 453         ret |= speed_sel | DW_USXGMII_FULL;
 454
 455         ret = xpcs_write(xpcs, MDIO_MMD_VEND2, MDIO_CTRL1, ret);
 456         if (ret < 0)
 457                 return ret;
 458
 459         ret = xpcs_read_vpcs(xpcs, MDIO_CTRL1);
 460         if (ret < 0)
 461                 return ret;
 462
 463         return xpcs_write_vpcs(xpcs, MDIO_CTRL1, ret | DW_USXGMII_RST);
 464 }
 465
 466 static int _xpcs_config_aneg_c73(struct mdio_xpcs_args *xpcs,
 467                                  const struct xpcs_compat *compat)
 468 {
 469         int ret, adv;
 470
 471         /* By default, in USXGMII mode XPCS operates at 10G baud and
 472          * replicates data to achieve lower speeds. Hereby, in this
 473          * default configuration we need to advertise all supported
 474          * modes and not only the ones we want to use.
 475          */
 476
 477         /* SR_AN_ADV3 */
 478         adv = 0;
 479         if (xpcs_linkmode_supported(compat, 2500baseX_Full))
 480                 adv |= DW_C73_2500KX;
 481
 482         /* TODO: 5000baseKR */
 483
 484         ret = xpcs_write(xpcs, MDIO_MMD_AN, DW_SR_AN_ADV3, adv);
 485         if (ret < 0)
 486                 return ret;
 487
 488         /* SR_AN_ADV2 */
 489         adv = 0;
 490         if (xpcs_linkmode_supported(compat, 1000baseKX_Full))
 491                 adv |= DW_C73_1000KX;
 492         if (xpcs_linkmode_supported(compat, 10000baseKX4_Full))
 493                 adv |= DW_C73_10000KX4;
 494         if (xpcs_linkmode_supported(compat, 10000baseKR_Full))
 495                 adv |= DW_C73_10000KR;
 496
 497         ret = xpcs_write(xpcs, MDIO_MMD_AN, DW_SR_AN_ADV2, adv);
 498         if (ret < 0)
 499                 return ret;
 500
 501         /* SR_AN_ADV1 */
 502         adv = DW_C73_AN_ADV_SF;
 503         if (xpcs_linkmode_supported(compat, Pause))
 504                 adv |= DW_C73_PAUSE;
 505         if (xpcs_linkmode_supported(compat, Asym_Pause))
 506                 adv |= DW_C73_ASYM_PAUSE;
 507
 508         return xpcs_write(xpcs, MDIO_MMD_AN, DW_SR_AN_ADV1, adv);
 509 }
 510
 511 static int xpcs_config_aneg_c73(struct mdio_xpcs_args *xpcs,
 512                                 const struct xpcs_compat *compat)
 513 {
 514         int ret;
 515
 516         ret = _xpcs_config_aneg_c73(xpcs, compat);
 517         if (ret < 0)
 518                 return ret;
 519
 520         ret = xpcs_read(xpcs, MDIO_MMD_AN, MDIO_CTRL1);
 521         if (ret < 0)
 522                 return ret;
 523
 524         ret |= MDIO_AN_CTRL1_ENABLE | MDIO_AN_CTRL1_RESTART;
 525
 526         return xpcs_write(xpcs, MDIO_MMD_AN, MDIO_CTRL1, ret);
 527 }
 528
 529 static int xpcs_aneg_done_c73(struct mdio_xpcs_args *xpcs,
 530                               struct phylink_link_state *state,
 531                               const struct xpcs_compat *compat)
 532 {
 533         int ret;
 534
 535         ret = xpcs_read(xpcs, MDIO_MMD_AN, MDIO_STAT1);
 536         if (ret < 0)
 537                 return ret;
 538
 539         if (ret & MDIO_AN_STAT1_COMPLETE) {
 540                 ret = xpcs_read(xpcs, MDIO_MMD_AN, DW_SR_AN_LP_ABL1);
 541                 if (ret < 0)
 542                         return ret;
 543
 544                 /* Check if Aneg outcome is valid */
 545                 if (!(ret & DW_C73_AN_ADV_SF)) {
 546                         xpcs_config_aneg_c73(xpcs, compat);
 547                         return 0;
 548                 }
 549
 550                 return 1;
 551         }
 552
 553         return 0;
 554 }
 555
 556 static int xpcs_read_lpa_c73(struct mdio_xpcs_args *xpcs,
 557                              struct phylink_link_state *state)
 558 {
 559         int ret;
 560
 561         ret = xpcs_read(xpcs, MDIO_MMD_AN, MDIO_STAT1);
 562         if (ret < 0)
 563                 return ret;
 564
 565         if (!(ret & MDIO_AN_STAT1_LPABLE)) {
 566                 phylink_clear(state->lp_advertising, Autoneg);
 567                 return 0;
 568         }
 569
 570         phylink_set(state->lp_advertising, Autoneg);
 571
 572         /* Clause 73 outcome */
 573         ret = xpcs_read(xpcs, MDIO_MMD_AN, DW_SR_AN_LP_ABL3);
 574         if (ret < 0)
 575                 return ret;
 576
 577         if (ret & DW_C73_2500KX)
 578                 phylink_set(state->lp_advertising, 2500baseX_Full);
 579
 580         ret = xpcs_read(xpcs, MDIO_MMD_AN, DW_SR_AN_LP_ABL2);
 581         if (ret < 0)
 582                 return ret;
 583
 584         if (ret & DW_C73_1000KX)
 585                 phylink_set(state->lp_advertising, 1000baseKX_Full);
 586         if (ret & DW_C73_10000KX4)
 587                 phylink_set(state->lp_advertising, 10000baseKX4_Full);
 588         if (ret & DW_C73_10000KR)
 589                 phylink_set(state->lp_advertising, 10000baseKR_Full);
 590
 591         ret = xpcs_read(xpcs, MDIO_MMD_AN, DW_SR_AN_LP_ABL1);
 592         if (ret < 0)
 593                 return ret;
 594
 595         if (ret & DW_C73_PAUSE)
 596                 phylink_set(state->lp_advertising, Pause);
 597         if (ret & DW_C73_ASYM_PAUSE)
 598                 phylink_set(state->lp_advertising, Asym_Pause);
 599
 600         linkmode_and(state->lp_advertising, state->lp_advertising,
 601                      state->advertising);
 602         return 0;
 603 }
 604
 605 static void xpcs_resolve_lpa_c73(struct mdio_xpcs_args *xpcs,
 606                                  struct phylink_link_state *state)
 607 {
 608         int max_speed = xpcs_get_max_usxgmii_speed(state->lp_advertising);
 609
 610         state->pause = MLO_PAUSE_TX | MLO_PAUSE_RX;
 611         state->speed = max_speed;
 612         state->duplex = DUPLEX_FULL;
 613 }
 614
 615 static int xpcs_get_max_xlgmii_speed(struct mdio_xpcs_args *xpcs,
 616                                      struct phylink_link_state *state)
 617 {
 618         unsigned long *adv = state->advertising;
 619         int speed = SPEED_UNKNOWN;
 620         int bit;
 621
 622         for_each_set_bit(bit, adv, __ETHTOOL_LINK_MODE_MASK_NBITS) {
 623                 int new_speed = SPEED_UNKNOWN;
 624
 625                 switch (bit) {
 626                 case ETHTOOL_LINK_MODE_25000baseCR_Full_BIT:
 627                 case ETHTOOL_LINK_MODE_25000baseKR_Full_BIT:
 628                 case ETHTOOL_LINK_MODE_25000baseSR_Full_BIT:
 629                         new_speed = SPEED_25000;
 630                         break;
 631                 case ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT:
 632                 case ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT:
 633                 case ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT:
 634                 case ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT:
 635                         new_speed = SPEED_40000;
 636                         break;
 637                 case ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT:
 638                 case ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT:
 639                 case ETHTOOL_LINK_MODE_50000baseSR2_Full_BIT:
 640                 case ETHTOOL_LINK_MODE_50000baseKR_Full_BIT:
 641                 case ETHTOOL_LINK_MODE_50000baseSR_Full_BIT:
 642                 case ETHTOOL_LINK_MODE_50000baseCR_Full_BIT:
 643                 case ETHTOOL_LINK_MODE_50000baseLR_ER_FR_Full_BIT:
 644                 case ETHTOOL_LINK_MODE_50000baseDR_Full_BIT:
 645                         new_speed = SPEED_50000;
 646                         break;
 647                 case ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT:
 648                 case ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT:
 649                 case ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT:
 650                 case ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT:
 651                 case ETHTOOL_LINK_MODE_100000baseKR2_Full_BIT:
 652                 case ETHTOOL_LINK_MODE_100000baseSR2_Full_BIT:
 653                 case ETHTOOL_LINK_MODE_100000baseCR2_Full_BIT:
 654                 case ETHTOOL_LINK_MODE_100000baseLR2_ER2_FR2_Full_BIT:
 655                 case ETHTOOL_LINK_MODE_100000baseDR2_Full_BIT:
 656                         new_speed = SPEED_100000;
 657                         break;
 658                 default:
 659                         continue;
 660                 }
 661
 662                 if (new_speed > speed)
 663                         speed = new_speed;
 664         }
 665
 666         return speed;
 667 }
 668
 669 static void xpcs_resolve_pma(struct mdio_xpcs_args *xpcs,
 670                              struct phylink_link_state *state)
 671 {
 672         state->pause = MLO_PAUSE_TX | MLO_PAUSE_RX;
 673         state->duplex = DUPLEX_FULL;
 674
 675         switch (state->interface) {
 676         case PHY_INTERFACE_MODE_10GKR:
 677                 state->speed = SPEED_10000;
 678                 break;
 679         case PHY_INTERFACE_MODE_XLGMII:
 680                 state->speed = xpcs_get_max_xlgmii_speed(xpcs, state);
 681                 break;
 682         default:
 683                 state->speed = SPEED_UNKNOWN;
 684                 break;
 685         }
 686 }
 687
 688 static int xpcs_validate(struct mdio_xpcs_args *xpcs,
 689                          unsigned long *supported,
 690                          struct phylink_link_state *state)
 691 {
 692         __ETHTOOL_DECLARE_LINK_MODE_MASK(xpcs_supported);
 693         const struct xpcs_compat *compat;
 694         int i;
 695
 696         /* phylink expects us to report all supported modes with
 697          * PHY_INTERFACE_MODE_NA, just don't limit the supported and
 698          * advertising masks and exit.
 699          */
 700         if (state->interface == PHY_INTERFACE_MODE_NA)
 701                 return 0;
 702
 703         bitmap_zero(xpcs_supported, __ETHTOOL_LINK_MODE_MASK_NBITS);
 704
 705         compat = xpcs_find_compat(xpcs->id, state->interface);
 706
 707         /* Populate the supported link modes for this
 708          * PHY interface type
 709          */
 710         if (compat)
 711                 for (i = 0; compat->supported[i] != __ETHTOOL_LINK_MODE_MASK_NBITS; i++)
 712                         set_bit(compat->supported[i], xpcs_supported);
 713
 714         linkmode_and(supported, supported, xpcs_supported);
 715         linkmode_and(state->advertising, state->advertising, xpcs_supported);
 716
 717         return 0;
 718 }
 719
 720 static int xpcs_config_eee(struct mdio_xpcs_args *xpcs, int mult_fact_100ns,
 721                            int enable)
 722 {
 723         int ret;
 724
 725         if (enable) {
 726         /* Enable EEE */
 727                 ret = DW_VR_MII_EEE_LTX_EN | DW_VR_MII_EEE_LRX_EN |
 728                       DW_VR_MII_EEE_TX_QUIET_EN | DW_VR_MII_EEE_RX_QUIET_EN |
 729                       DW_VR_MII_EEE_TX_EN_CTRL | DW_VR_MII_EEE_RX_EN_CTRL |
 730                       mult_fact_100ns << DW_VR_MII_EEE_MULT_FACT_100NS_SHIFT;
 731         } else {
 732                 ret = xpcs_read(xpcs, MDIO_MMD_VEND2, DW_VR_MII_EEE_MCTRL0);
 733                 if (ret < 0)
 734                         return ret;
 735                 ret &= ~(DW_VR_MII_EEE_LTX_EN | DW_VR_MII_EEE_LRX_EN |
 736                        DW_VR_MII_EEE_TX_QUIET_EN | DW_VR_MII_EEE_RX_QUIET_EN |
 737                        DW_VR_MII_EEE_TX_EN_CTRL | DW_VR_MII_EEE_RX_EN_CTRL |
 738                        DW_VR_MII_EEE_MULT_FACT_100NS);
 739         }
 740
 741         ret = xpcs_write(xpcs, MDIO_MMD_VEND2, DW_VR_MII_EEE_MCTRL0, ret);
 742         if (ret < 0)
 743                 return ret;
 744
 745         ret = xpcs_read(xpcs, MDIO_MMD_VEND2, DW_VR_MII_EEE_MCTRL1);
 746         if (ret < 0)
 747                 return ret;
 748
 749         ret |= DW_VR_MII_EEE_TRN_LPI;
 750         return xpcs_write(xpcs, MDIO_MMD_VEND2, DW_VR_MII_EEE_MCTRL1, ret);
 751 }
 752
 753 static int xpcs_config_aneg_c37_sgmii(struct mdio_xpcs_args *xpcs)
 754 {
 755         int ret;
 756
 757         /* For AN for C37 SGMII mode, the settings are :-
 758          * 1) VR_MII_AN_CTRL Bit(2:1)[PCS_MODE] = 10b (SGMII AN)
 759          * 2) VR_MII_AN_CTRL Bit(3) [TX_CONFIG] = 0b (MAC side SGMII)
 760          *    DW xPCS used with DW EQoS MAC is always MAC side SGMII.
 761          * 3) VR_MII_DIG_CTRL1 Bit(9) [MAC_AUTO_SW] = 1b (Automatic
 762          *    speed/duplex mode change by HW after SGMII AN complete)
 763          *
 764          * Note: Since it is MAC side SGMII, there is no need to set
 765          *       SR_MII_AN_ADV. MAC side SGMII receives AN Tx Config from
 766          *       PHY about the link state change after C28 AN is completed
 767          *       between PHY and Link Partner. There is also no need to
 768          *       trigger AN restart for MAC-side SGMII.
 769          */
 770         ret = xpcs_read(xpcs, MDIO_MMD_VEND2, DW_VR_MII_AN_CTRL);
 771         if (ret < 0)
 772                 return ret;
 773
 774         ret &= ~(DW_VR_MII_PCS_MODE_MASK | DW_VR_MII_TX_CONFIG_MASK);
 775         ret |= (DW_VR_MII_PCS_MODE_C37_SGMII <<
 776                 DW_VR_MII_AN_CTRL_PCS_MODE_SHIFT &
 777                 DW_VR_MII_PCS_MODE_MASK);
 778         ret |= (DW_VR_MII_TX_CONFIG_MAC_SIDE_SGMII <<
 779                 DW_VR_MII_AN_CTRL_TX_CONFIG_SHIFT &
 780                 DW_VR_MII_TX_CONFIG_MASK);
 781         ret = xpcs_write(xpcs, MDIO_MMD_VEND2, DW_VR_MII_AN_CTRL, ret);
 782         if (ret < 0)
 783                 return ret;
 784
 785         ret = xpcs_read(xpcs, MDIO_MMD_VEND2, DW_VR_MII_DIG_CTRL1);
 786         if (ret < 0)
 787                 return ret;
 788
 789         ret |= DW_VR_MII_DIG_CTRL1_MAC_AUTO_SW;
 790
 791         return xpcs_write(xpcs, MDIO_MMD_VEND2, DW_VR_MII_DIG_CTRL1, ret);
 792 }
 793
 794 static int xpcs_config(struct mdio_xpcs_args *xpcs,
 795                        const struct phylink_link_state *state)
 796 {
 797         const struct xpcs_compat *compat;
 798         int ret;
 799
 800         compat = xpcs_find_compat(xpcs->id, state->interface);
 801         if (!compat)
 802                 return -ENODEV;
 803
 804         switch (compat->an_mode) {
 805         case DW_AN_C73:
 806                 if (state->an_enabled) {
 807                         ret = xpcs_config_aneg_c73(xpcs, compat);
 808                         if (ret)
 809                                 return ret;
 810                 }
 811                 break;
 812         case DW_AN_C37_SGMII:
 813                 ret = xpcs_config_aneg_c37_sgmii(xpcs);
 814                 if (ret)
 815                         return ret;
 816                 break;
 817         default:
 818                 return -1;
 819         }
 820
 821         return 0;
 822 }
 823
 824 static int xpcs_get_state_c73(struct mdio_xpcs_args *xpcs,
 825                               struct phylink_link_state *state,
 826                               const struct xpcs_compat *compat)
 827 {
 828         int ret;
 829
 830         /* Link needs to be read first ... */
 831         state->link = xpcs_read_link_c73(xpcs, state->an_enabled) > 0 ? 1 : 0;
 832
 833         /* ... and then we check the faults. */
 834         ret = xpcs_read_fault_c73(xpcs, state);
 835         if (ret) {
 836                 ret = xpcs_soft_reset(xpcs, compat);
 837                 if (ret)
 838                         return ret;
 839
 840                 state->link = 0;
 841
 842                 return xpcs_config(xpcs, state);
 843         }
 844
 845         if (state->an_enabled && xpcs_aneg_done_c73(xpcs, state, compat)) {
 846                 state->an_complete = true;
 847                 xpcs_read_lpa_c73(xpcs, state);
 848                 xpcs_resolve_lpa_c73(xpcs, state);
 849         } else if (state->an_enabled) {
 850                 state->link = 0;
 851         } else if (state->link) {
 852                 xpcs_resolve_pma(xpcs, state);
 853         }
 854
 855         return 0;
 856 }
 857
 858 static int xpcs_get_state_c37_sgmii(struct mdio_xpcs_args *xpcs,
 859                                     struct phylink_link_state *state)
 860 {
 861         int ret;
 862
 863         /* Reset link_state */
 864         state->link = false;
 865         state->speed = SPEED_UNKNOWN;
 866         state->duplex = DUPLEX_UNKNOWN;
 867         state->pause = 0;
 868
 869         /* For C37 SGMII mode, we check DW_VR_MII_AN_INTR_STS for link
 870          * status, speed and duplex.
 871          */
 872         ret = xpcs_read(xpcs, MDIO_MMD_VEND2, DW_VR_MII_AN_INTR_STS);
 873         if (ret < 0)
 874                 return false;
 875
 876         if (ret & DW_VR_MII_C37_ANSGM_SP_LNKSTS) {
 877                 int speed_value;
 878
 879                 state->link = true;
 880
 881                 speed_value = (ret & DW_VR_MII_AN_STS_C37_ANSGM_SP) >>
 882                               DW_VR_MII_AN_STS_C37_ANSGM_SP_SHIFT;
 883                 if (speed_value == DW_VR_MII_C37_ANSGM_SP_1000)
 884                         state->speed = SPEED_1000;
 885                 else if (speed_value == DW_VR_MII_C37_ANSGM_SP_100)
 886                         state->speed = SPEED_100;
 887                 else
 888                         state->speed = SPEED_10;
 889
 890                 if (ret & DW_VR_MII_AN_STS_C37_ANSGM_FD)
 891                         state->duplex = DUPLEX_FULL;
 892                 else
 893                         state->duplex = DUPLEX_HALF;
 894         }
 895
 896         return 0;
 897 }
 898
 899 static int xpcs_get_state(struct mdio_xpcs_args *xpcs,
 900                           struct phylink_link_state *state)
 901 {
 902         const struct xpcs_compat *compat;
 903         int ret;
 904
 905         compat = xpcs_find_compat(xpcs->id, state->interface);
 906         if (!compat)
 907                 return -ENODEV;
 908
 909         switch (compat->an_mode) {
 910         case DW_AN_C73:
 911                 ret = xpcs_get_state_c73(xpcs, state, compat);
 912                 if (ret)
 913                         return ret;
 914                 break;
 915         case DW_AN_C37_SGMII:
 916                 ret = xpcs_get_state_c37_sgmii(xpcs, state);
 917                 if (ret)
 918                         return ret;
 919                 break;
 920         default:
 921                 return -1;
 922         }
 923
 924         return 0;
 925 }
 926
 927 static int xpcs_link_up(struct mdio_xpcs_args *xpcs, int speed,
 928                         phy_interface_t interface)
 929 {
 930         if (interface == PHY_INTERFACE_MODE_USXGMII)
 931                 return xpcs_config_usxgmii(xpcs, speed);
 932
 933         return 0;
 934 }
 935
 936 static u32 xpcs_get_id(struct mdio_xpcs_args *xpcs)
 937 {
 938         int ret;
 939         u32 id;
 940
 941         /* First, search C73 PCS using PCS MMD */
 942         ret = xpcs_read(xpcs, MDIO_MMD_PCS, MII_PHYSID1);
 943         if (ret < 0)
 944                 return 0xffffffff;
 945
 946         id = ret << 16;
 947
 948         ret = xpcs_read(xpcs, MDIO_MMD_PCS, MII_PHYSID2);
 949         if (ret < 0)
 950                 return 0xffffffff;
 951
 952         /* If Device IDs are not all zeros, we found C73 AN-type device */
 953         if (id | ret)
 954                 return id | ret;
 955
 956         /* Next, search C37 PCS using Vendor-Specific MII MMD */
 957         ret = xpcs_read(xpcs, MDIO_MMD_VEND2, MII_PHYSID1);
 958         if (ret < 0)
 959                 return 0xffffffff;
 960
 961         id = ret << 16;
 962
 963         ret = xpcs_read(xpcs, MDIO_MMD_VEND2, MII_PHYSID2);
 964         if (ret < 0)
 965                 return 0xffffffff;
 966
 967         /* If Device IDs are not all zeros, we found C37 AN-type device */
 968         if (id | ret)
 969                 return id | ret;
 970
 971         return 0xffffffff;
 972 }
 973
 974 static const struct xpcs_compat synopsys_xpcs_compat[DW_XPCS_INTERFACE_MAX] = {
 975         [DW_XPCS_USXGMII] = {
 976                 .supported = xpcs_usxgmii_features,
 977                 .interface = xpcs_usxgmii_interfaces,
 978                 .num_interfaces = ARRAY_SIZE(xpcs_usxgmii_interfaces),
 979                 .an_mode = DW_AN_C73,
 980         },
 981         [DW_XPCS_10GKR] = {
 982                 .supported = xpcs_10gkr_features,
 983                 .interface = xpcs_10gkr_interfaces,
 984                 .num_interfaces = ARRAY_SIZE(xpcs_10gkr_interfaces),
 985                 .an_mode = DW_AN_C73,
 986         },
 987         [DW_XPCS_XLGMII] = {
 988                 .supported = xpcs_xlgmii_features,
 989                 .interface = xpcs_xlgmii_interfaces,
 990                 .num_interfaces = ARRAY_SIZE(xpcs_xlgmii_interfaces),
 991                 .an_mode = DW_AN_C73,
 992         },
 993         [DW_XPCS_SGMII] = {
 994                 .supported = xpcs_sgmii_features,
 995                 .interface = xpcs_sgmii_interfaces,
 996                 .num_interfaces = ARRAY_SIZE(xpcs_sgmii_interfaces),
 997                 .an_mode = DW_AN_C37_SGMII,
 998         },
 999 };
1000
1001 static const struct xpcs_id xpcs_id_list[] = {
1002         {
1003                 .id = SYNOPSYS_XPCS_ID,
1004                 .mask = SYNOPSYS_XPCS_MASK,
1005                 .compat = synopsys_xpcs_compat,
1006         },
1007 };
1008
1009 static int xpcs_probe(struct mdio_xpcs_args *xpcs, phy_interface_t interface)
1010 {
1011         u32 xpcs_id = xpcs_get_id(xpcs);
1012         int i;
1013
1014         for (i = 0; i < ARRAY_SIZE(xpcs_id_list); i++) {
1015                 const struct xpcs_id *entry = &xpcs_id_list[i];
1016                 const struct xpcs_compat *compat;
1017
1018                 if ((xpcs_id & entry->mask) != entry->id)
1019                         continue;
1020
1021                 xpcs->id = entry;
1022
1023                 compat = xpcs_find_compat(entry, interface);
1024                 if (!compat)
1025                         return -ENODEV;
1026
1027                 return xpcs_soft_reset(xpcs, compat);
1028         }
1029
1030         return -ENODEV;
1031 }
1032
1033 static struct mdio_xpcs_ops xpcs_ops = {
1034         .validate = xpcs_validate,
1035         .config = xpcs_config,
1036         .get_state = xpcs_get_state,
1037         .link_up = xpcs_link_up,
1038         .probe = xpcs_probe,
1039         .config_eee = xpcs_config_eee,
1040 };
1041
1042 struct mdio_xpcs_ops *mdio_xpcs_get_ops(void)
1043 {
1044         return &xpcs_ops;
1045 }
1046 EXPORT_SYMBOL_GPL(mdio_xpcs_get_ops);
1047
1048 MODULE_LICENSE("GPL v2");