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 = mdiobus_c45_addr(dev, reg);
 244         struct mii_bus *bus = xpcs->mdiodev->bus;
 245         int addr = xpcs->mdiodev->addr;
 246
 247         return mdiobus_read(bus, addr, reg_addr);
 248 }
 249
 250 static int xpcs_write(struct mdio_xpcs_args *xpcs, int dev, u32 reg, u16 val)
 251 {
 252         u32 reg_addr = mdiobus_c45_addr(dev, reg);
 253         struct mii_bus *bus = xpcs->mdiodev->bus;
 254         int addr = xpcs->mdiodev->addr;
 255
 256         return mdiobus_write(bus, addr, reg_addr, val);
 257 }
 258
 259 static int xpcs_read_vendor(struct mdio_xpcs_args *xpcs, int dev, u32 reg)
 260 {
 261         return xpcs_read(xpcs, dev, DW_VENDOR | reg);
 262 }
 263
 264 static int xpcs_write_vendor(struct mdio_xpcs_args *xpcs, int dev, int reg,
 265                              u16 val)
 266 {
 267         return xpcs_write(xpcs, dev, DW_VENDOR | reg, val);
 268 }
 269
 270 static int xpcs_read_vpcs(struct mdio_xpcs_args *xpcs, int reg)
 271 {
 272         return xpcs_read_vendor(xpcs, MDIO_MMD_PCS, reg);
 273 }
 274
 275 static int xpcs_write_vpcs(struct mdio_xpcs_args *xpcs, int reg, u16 val)
 276 {
 277         return xpcs_write_vendor(xpcs, MDIO_MMD_PCS, reg, val);
 278 }
 279
 280 static int xpcs_poll_reset(struct mdio_xpcs_args *xpcs, int dev)
 281 {
 282         /* Poll until the reset bit clears (50ms per retry == 0.6 sec) */
 283         unsigned int retries = 12;
 284         int ret;
 285
 286         do {
 287                 msleep(50);
 288                 ret = xpcs_read(xpcs, dev, MDIO_CTRL1);
 289                 if (ret < 0)
 290                         return ret;
 291         } while (ret & MDIO_CTRL1_RESET && --retries);
 292
 293         return (ret & MDIO_CTRL1_RESET) ? -ETIMEDOUT : 0;
 294 }
 295
 296 static int xpcs_soft_reset(struct mdio_xpcs_args *xpcs,
 297                            const struct xpcs_compat *compat)
 298 {
 299         int ret, dev;
 300
 301         switch (compat->an_mode) {
 302         case DW_AN_C73:
 303                 dev = MDIO_MMD_PCS;
 304                 break;
 305         case DW_AN_C37_SGMII:
 306                 dev = MDIO_MMD_VEND2;
 307                 break;
 308         default:
 309                 return -1;
 310         }
 311
 312         ret = xpcs_write(xpcs, dev, MDIO_CTRL1, MDIO_CTRL1_RESET);
 313         if (ret < 0)
 314                 return ret;
 315
 316         return xpcs_poll_reset(xpcs, dev);
 317 }
 318
 319 #define xpcs_warn(__xpcs, __state, __args...) \
 320 ({ \
 321         if ((__state)->link) \
 322                 dev_warn(&(__xpcs)->mdiodev->dev, ##__args); \
 323 })
 324
 325 static int xpcs_read_fault_c73(struct mdio_xpcs_args *xpcs,
 326                                struct phylink_link_state *state)
 327 {
 328         int ret;
 329
 330         ret = xpcs_read(xpcs, MDIO_MMD_PCS, MDIO_STAT1);
 331         if (ret < 0)
 332                 return ret;
 333
 334         if (ret & MDIO_STAT1_FAULT) {
 335                 xpcs_warn(xpcs, state, "Link fault condition detected!\n");
 336                 return -EFAULT;
 337         }
 338
 339         ret = xpcs_read(xpcs, MDIO_MMD_PCS, MDIO_STAT2);
 340         if (ret < 0)
 341                 return ret;
 342
 343         if (ret & MDIO_STAT2_RXFAULT)
 344                 xpcs_warn(xpcs, state, "Receiver fault detected!\n");
 345         if (ret & MDIO_STAT2_TXFAULT)
 346                 xpcs_warn(xpcs, state, "Transmitter fault detected!\n");
 347
 348         ret = xpcs_read_vendor(xpcs, MDIO_MMD_PCS, DW_VR_XS_PCS_DIG_STS);
 349         if (ret < 0)
 350                 return ret;
 351
 352         if (ret & DW_RXFIFO_ERR) {
 353                 xpcs_warn(xpcs, state, "FIFO fault condition detected!\n");
 354                 return -EFAULT;
 355         }
 356
 357         ret = xpcs_read(xpcs, MDIO_MMD_PCS, MDIO_PCS_10GBRT_STAT1);
 358         if (ret < 0)
 359                 return ret;
 360
 361         if (!(ret & MDIO_PCS_10GBRT_STAT1_BLKLK))
 362                 xpcs_warn(xpcs, state, "Link is not locked!\n");
 363
 364         ret = xpcs_read(xpcs, MDIO_MMD_PCS, MDIO_PCS_10GBRT_STAT2);
 365         if (ret < 0)
 366                 return ret;
 367
 368         if (ret & MDIO_PCS_10GBRT_STAT2_ERR) {
 369                 xpcs_warn(xpcs, state, "Link has errors!\n");
 370                 return -EFAULT;
 371         }
 372
 373         return 0;
 374 }
 375
 376 static int xpcs_read_link_c73(struct mdio_xpcs_args *xpcs, bool an)
 377 {
 378         bool link = true;
 379         int ret;
 380
 381         ret = xpcs_read(xpcs, MDIO_MMD_PCS, MDIO_STAT1);
 382         if (ret < 0)
 383                 return ret;
 384
 385         if (!(ret & MDIO_STAT1_LSTATUS))
 386                 link = false;
 387
 388         if (an) {
 389                 ret = xpcs_read(xpcs, MDIO_MMD_AN, MDIO_STAT1);
 390                 if (ret < 0)
 391                         return ret;
 392
 393                 if (!(ret & MDIO_STAT1_LSTATUS))
 394                         link = false;
 395         }
 396
 397         return link;
 398 }
 399
 400 static int xpcs_get_max_usxgmii_speed(const unsigned long *supported)
 401 {
 402         int max = SPEED_UNKNOWN;
 403
 404         if (phylink_test(supported, 1000baseKX_Full))
 405                 max = SPEED_1000;
 406         if (phylink_test(supported, 2500baseX_Full))
 407                 max = SPEED_2500;
 408         if (phylink_test(supported, 10000baseKX4_Full))
 409                 max = SPEED_10000;
 410         if (phylink_test(supported, 10000baseKR_Full))
 411                 max = SPEED_10000;
 412
 413         return max;
 414 }
 415
 416 static int xpcs_config_usxgmii(struct mdio_xpcs_args *xpcs, int speed)
 417 {
 418         int ret, speed_sel;
 419
 420         switch (speed) {
 421         case SPEED_10:
 422                 speed_sel = DW_USXGMII_10;
 423                 break;
 424         case SPEED_100:
 425                 speed_sel = DW_USXGMII_100;
 426                 break;
 427         case SPEED_1000:
 428                 speed_sel = DW_USXGMII_1000;
 429                 break;
 430         case SPEED_2500:
 431                 speed_sel = DW_USXGMII_2500;
 432                 break;
 433         case SPEED_5000:
 434                 speed_sel = DW_USXGMII_5000;
 435                 break;
 436         case SPEED_10000:
 437                 speed_sel = DW_USXGMII_10000;
 438                 break;
 439         default:
 440                 /* Nothing to do here */
 441                 return -EINVAL;
 442         }
 443
 444         ret = xpcs_read_vpcs(xpcs, MDIO_CTRL1);
 445         if (ret < 0)
 446                 return ret;
 447
 448         ret = xpcs_write_vpcs(xpcs, MDIO_CTRL1, ret | DW_USXGMII_EN);
 449         if (ret < 0)
 450                 return ret;
 451
 452         ret = xpcs_read(xpcs, MDIO_MMD_VEND2, MDIO_CTRL1);
 453         if (ret < 0)
 454                 return ret;
 455
 456         ret &= ~DW_USXGMII_SS_MASK;
 457         ret |= speed_sel | DW_USXGMII_FULL;
 458
 459         ret = xpcs_write(xpcs, MDIO_MMD_VEND2, MDIO_CTRL1, ret);
 460         if (ret < 0)
 461                 return ret;
 462
 463         ret = xpcs_read_vpcs(xpcs, MDIO_CTRL1);
 464         if (ret < 0)
 465                 return ret;
 466
 467         return xpcs_write_vpcs(xpcs, MDIO_CTRL1, ret | DW_USXGMII_RST);
 468 }
 469
 470 static int _xpcs_config_aneg_c73(struct mdio_xpcs_args *xpcs,
 471                                  const struct xpcs_compat *compat)
 472 {
 473         int ret, adv;
 474
 475         /* By default, in USXGMII mode XPCS operates at 10G baud and
 476          * replicates data to achieve lower speeds. Hereby, in this
 477          * default configuration we need to advertise all supported
 478          * modes and not only the ones we want to use.
 479          */
 480
 481         /* SR_AN_ADV3 */
 482         adv = 0;
 483         if (xpcs_linkmode_supported(compat, 2500baseX_Full))
 484                 adv |= DW_C73_2500KX;
 485
 486         /* TODO: 5000baseKR */
 487
 488         ret = xpcs_write(xpcs, MDIO_MMD_AN, DW_SR_AN_ADV3, adv);
 489         if (ret < 0)
 490                 return ret;
 491
 492         /* SR_AN_ADV2 */
 493         adv = 0;
 494         if (xpcs_linkmode_supported(compat, 1000baseKX_Full))
 495                 adv |= DW_C73_1000KX;
 496         if (xpcs_linkmode_supported(compat, 10000baseKX4_Full))
 497                 adv |= DW_C73_10000KX4;
 498         if (xpcs_linkmode_supported(compat, 10000baseKR_Full))
 499                 adv |= DW_C73_10000KR;
 500
 501         ret = xpcs_write(xpcs, MDIO_MMD_AN, DW_SR_AN_ADV2, adv);
 502         if (ret < 0)
 503                 return ret;
 504
 505         /* SR_AN_ADV1 */
 506         adv = DW_C73_AN_ADV_SF;
 507         if (xpcs_linkmode_supported(compat, Pause))
 508                 adv |= DW_C73_PAUSE;
 509         if (xpcs_linkmode_supported(compat, Asym_Pause))
 510                 adv |= DW_C73_ASYM_PAUSE;
 511
 512         return xpcs_write(xpcs, MDIO_MMD_AN, DW_SR_AN_ADV1, adv);
 513 }
 514
 515 static int xpcs_config_aneg_c73(struct mdio_xpcs_args *xpcs,
 516                                 const struct xpcs_compat *compat)
 517 {
 518         int ret;
 519
 520         ret = _xpcs_config_aneg_c73(xpcs, compat);
 521         if (ret < 0)
 522                 return ret;
 523
 524         ret = xpcs_read(xpcs, MDIO_MMD_AN, MDIO_CTRL1);
 525         if (ret < 0)
 526                 return ret;
 527
 528         ret |= MDIO_AN_CTRL1_ENABLE | MDIO_AN_CTRL1_RESTART;
 529
 530         return xpcs_write(xpcs, MDIO_MMD_AN, MDIO_CTRL1, ret);
 531 }
 532
 533 static int xpcs_aneg_done_c73(struct mdio_xpcs_args *xpcs,
 534                               struct phylink_link_state *state,
 535                               const struct xpcs_compat *compat)
 536 {
 537         int ret;
 538
 539         ret = xpcs_read(xpcs, MDIO_MMD_AN, MDIO_STAT1);
 540         if (ret < 0)
 541                 return ret;
 542
 543         if (ret & MDIO_AN_STAT1_COMPLETE) {
 544                 ret = xpcs_read(xpcs, MDIO_MMD_AN, DW_SR_AN_LP_ABL1);
 545                 if (ret < 0)
 546                         return ret;
 547
 548                 /* Check if Aneg outcome is valid */
 549                 if (!(ret & DW_C73_AN_ADV_SF)) {
 550                         xpcs_config_aneg_c73(xpcs, compat);
 551                         return 0;
 552                 }
 553
 554                 return 1;
 555         }
 556
 557         return 0;
 558 }
 559
 560 static int xpcs_read_lpa_c73(struct mdio_xpcs_args *xpcs,
 561                              struct phylink_link_state *state)
 562 {
 563         int ret;
 564
 565         ret = xpcs_read(xpcs, MDIO_MMD_AN, MDIO_STAT1);
 566         if (ret < 0)
 567                 return ret;
 568
 569         if (!(ret & MDIO_AN_STAT1_LPABLE)) {
 570                 phylink_clear(state->lp_advertising, Autoneg);
 571                 return 0;
 572         }
 573
 574         phylink_set(state->lp_advertising, Autoneg);
 575
 576         /* Clause 73 outcome */
 577         ret = xpcs_read(xpcs, MDIO_MMD_AN, DW_SR_AN_LP_ABL3);
 578         if (ret < 0)
 579                 return ret;
 580
 581         if (ret & DW_C73_2500KX)
 582                 phylink_set(state->lp_advertising, 2500baseX_Full);
 583
 584         ret = xpcs_read(xpcs, MDIO_MMD_AN, DW_SR_AN_LP_ABL2);
 585         if (ret < 0)
 586                 return ret;
 587
 588         if (ret & DW_C73_1000KX)
 589                 phylink_set(state->lp_advertising, 1000baseKX_Full);
 590         if (ret & DW_C73_10000KX4)
 591                 phylink_set(state->lp_advertising, 10000baseKX4_Full);
 592         if (ret & DW_C73_10000KR)
 593                 phylink_set(state->lp_advertising, 10000baseKR_Full);
 594
 595         ret = xpcs_read(xpcs, MDIO_MMD_AN, DW_SR_AN_LP_ABL1);
 596         if (ret < 0)
 597                 return ret;
 598
 599         if (ret & DW_C73_PAUSE)
 600                 phylink_set(state->lp_advertising, Pause);
 601         if (ret & DW_C73_ASYM_PAUSE)
 602                 phylink_set(state->lp_advertising, Asym_Pause);
 603
 604         linkmode_and(state->lp_advertising, state->lp_advertising,
 605                      state->advertising);
 606         return 0;
 607 }
 608
 609 static void xpcs_resolve_lpa_c73(struct mdio_xpcs_args *xpcs,
 610                                  struct phylink_link_state *state)
 611 {
 612         int max_speed = xpcs_get_max_usxgmii_speed(state->lp_advertising);
 613
 614         state->pause = MLO_PAUSE_TX | MLO_PAUSE_RX;
 615         state->speed = max_speed;
 616         state->duplex = DUPLEX_FULL;
 617 }
 618
 619 static int xpcs_get_max_xlgmii_speed(struct mdio_xpcs_args *xpcs,
 620                                      struct phylink_link_state *state)
 621 {
 622         unsigned long *adv = state->advertising;
 623         int speed = SPEED_UNKNOWN;
 624         int bit;
 625
 626         for_each_set_bit(bit, adv, __ETHTOOL_LINK_MODE_MASK_NBITS) {
 627                 int new_speed = SPEED_UNKNOWN;
 628
 629                 switch (bit) {
 630                 case ETHTOOL_LINK_MODE_25000baseCR_Full_BIT:
 631                 case ETHTOOL_LINK_MODE_25000baseKR_Full_BIT:
 632                 case ETHTOOL_LINK_MODE_25000baseSR_Full_BIT:
 633                         new_speed = SPEED_25000;
 634                         break;
 635                 case ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT:
 636                 case ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT:
 637                 case ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT:
 638                 case ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT:
 639                         new_speed = SPEED_40000;
 640                         break;
 641                 case ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT:
 642                 case ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT:
 643                 case ETHTOOL_LINK_MODE_50000baseSR2_Full_BIT:
 644                 case ETHTOOL_LINK_MODE_50000baseKR_Full_BIT:
 645                 case ETHTOOL_LINK_MODE_50000baseSR_Full_BIT:
 646                 case ETHTOOL_LINK_MODE_50000baseCR_Full_BIT:
 647                 case ETHTOOL_LINK_MODE_50000baseLR_ER_FR_Full_BIT:
 648                 case ETHTOOL_LINK_MODE_50000baseDR_Full_BIT:
 649                         new_speed = SPEED_50000;
 650                         break;
 651                 case ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT:
 652                 case ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT:
 653                 case ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT:
 654                 case ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT:
 655                 case ETHTOOL_LINK_MODE_100000baseKR2_Full_BIT:
 656                 case ETHTOOL_LINK_MODE_100000baseSR2_Full_BIT:
 657                 case ETHTOOL_LINK_MODE_100000baseCR2_Full_BIT:
 658                 case ETHTOOL_LINK_MODE_100000baseLR2_ER2_FR2_Full_BIT:
 659                 case ETHTOOL_LINK_MODE_100000baseDR2_Full_BIT:
 660                         new_speed = SPEED_100000;
 661                         break;
 662                 default:
 663                         continue;
 664                 }
 665
 666                 if (new_speed > speed)
 667                         speed = new_speed;
 668         }
 669
 670         return speed;
 671 }
 672
 673 static void xpcs_resolve_pma(struct mdio_xpcs_args *xpcs,
 674                              struct phylink_link_state *state)
 675 {
 676         state->pause = MLO_PAUSE_TX | MLO_PAUSE_RX;
 677         state->duplex = DUPLEX_FULL;
 678
 679         switch (state->interface) {
 680         case PHY_INTERFACE_MODE_10GKR:
 681                 state->speed = SPEED_10000;
 682                 break;
 683         case PHY_INTERFACE_MODE_XLGMII:
 684                 state->speed = xpcs_get_max_xlgmii_speed(xpcs, state);
 685                 break;
 686         default:
 687                 state->speed = SPEED_UNKNOWN;
 688                 break;
 689         }
 690 }
 691
 692 void xpcs_validate(struct mdio_xpcs_args *xpcs, unsigned long *supported,
 693                    struct phylink_link_state *state)
 694 {
 695         __ETHTOOL_DECLARE_LINK_MODE_MASK(xpcs_supported);
 696         const struct xpcs_compat *compat;
 697         int i;
 698
 699         /* phylink expects us to report all supported modes with
 700          * PHY_INTERFACE_MODE_NA, just don't limit the supported and
 701          * advertising masks and exit.
 702          */
 703         if (state->interface == PHY_INTERFACE_MODE_NA)
 704                 return;
 705
 706         bitmap_zero(xpcs_supported, __ETHTOOL_LINK_MODE_MASK_NBITS);
 707
 708         compat = xpcs_find_compat(xpcs->id, state->interface);
 709
 710         /* Populate the supported link modes for this
 711          * PHY interface type
 712          */
 713         if (compat)
 714                 for (i = 0; compat->supported[i] != __ETHTOOL_LINK_MODE_MASK_NBITS; i++)
 715                         set_bit(compat->supported[i], xpcs_supported);
 716
 717         linkmode_and(supported, supported, xpcs_supported);
 718         linkmode_and(state->advertising, state->advertising, xpcs_supported);
 719 }
 720 EXPORT_SYMBOL_GPL(xpcs_validate);
 721
 722 int xpcs_config_eee(struct mdio_xpcs_args *xpcs, int mult_fact_100ns,
 723                     int enable)
 724 {
 725         int ret;
 726
 727         if (enable) {
 728         /* Enable EEE */
 729                 ret = DW_VR_MII_EEE_LTX_EN | DW_VR_MII_EEE_LRX_EN |
 730                       DW_VR_MII_EEE_TX_QUIET_EN | DW_VR_MII_EEE_RX_QUIET_EN |
 731                       DW_VR_MII_EEE_TX_EN_CTRL | DW_VR_MII_EEE_RX_EN_CTRL |
 732                       mult_fact_100ns << DW_VR_MII_EEE_MULT_FACT_100NS_SHIFT;
 733         } else {
 734                 ret = xpcs_read(xpcs, MDIO_MMD_VEND2, DW_VR_MII_EEE_MCTRL0);
 735                 if (ret < 0)
 736                         return ret;
 737                 ret &= ~(DW_VR_MII_EEE_LTX_EN | DW_VR_MII_EEE_LRX_EN |
 738                        DW_VR_MII_EEE_TX_QUIET_EN | DW_VR_MII_EEE_RX_QUIET_EN |
 739                        DW_VR_MII_EEE_TX_EN_CTRL | DW_VR_MII_EEE_RX_EN_CTRL |
 740                        DW_VR_MII_EEE_MULT_FACT_100NS);
 741         }
 742
 743         ret = xpcs_write(xpcs, MDIO_MMD_VEND2, DW_VR_MII_EEE_MCTRL0, ret);
 744         if (ret < 0)
 745                 return ret;
 746
 747         ret = xpcs_read(xpcs, MDIO_MMD_VEND2, DW_VR_MII_EEE_MCTRL1);
 748         if (ret < 0)
 749                 return ret;
 750
 751         ret |= DW_VR_MII_EEE_TRN_LPI;
 752         return xpcs_write(xpcs, MDIO_MMD_VEND2, DW_VR_MII_EEE_MCTRL1, ret);
 753 }
 754 EXPORT_SYMBOL_GPL(xpcs_config_eee);
 755
 756 static int xpcs_config_aneg_c37_sgmii(struct mdio_xpcs_args *xpcs)
 757 {
 758         int ret;
 759
 760         /* For AN for C37 SGMII mode, the settings are :-
 761          * 1) VR_MII_AN_CTRL Bit(2:1)[PCS_MODE] = 10b (SGMII AN)
 762          * 2) VR_MII_AN_CTRL Bit(3) [TX_CONFIG] = 0b (MAC side SGMII)
 763          *    DW xPCS used with DW EQoS MAC is always MAC side SGMII.
 764          * 3) VR_MII_DIG_CTRL1 Bit(9) [MAC_AUTO_SW] = 1b (Automatic
 765          *    speed/duplex mode change by HW after SGMII AN complete)
 766          *
 767          * Note: Since it is MAC side SGMII, there is no need to set
 768          *       SR_MII_AN_ADV. MAC side SGMII receives AN Tx Config from
 769          *       PHY about the link state change after C28 AN is completed
 770          *       between PHY and Link Partner. There is also no need to
 771          *       trigger AN restart for MAC-side SGMII.
 772          */
 773         ret = xpcs_read(xpcs, MDIO_MMD_VEND2, DW_VR_MII_AN_CTRL);
 774         if (ret < 0)
 775                 return ret;
 776
 777         ret &= ~(DW_VR_MII_PCS_MODE_MASK | DW_VR_MII_TX_CONFIG_MASK);
 778         ret |= (DW_VR_MII_PCS_MODE_C37_SGMII <<
 779                 DW_VR_MII_AN_CTRL_PCS_MODE_SHIFT &
 780                 DW_VR_MII_PCS_MODE_MASK);
 781         ret |= (DW_VR_MII_TX_CONFIG_MAC_SIDE_SGMII <<
 782                 DW_VR_MII_AN_CTRL_TX_CONFIG_SHIFT &
 783                 DW_VR_MII_TX_CONFIG_MASK);
 784         ret = xpcs_write(xpcs, MDIO_MMD_VEND2, DW_VR_MII_AN_CTRL, ret);
 785         if (ret < 0)
 786                 return ret;
 787
 788         ret = xpcs_read(xpcs, MDIO_MMD_VEND2, DW_VR_MII_DIG_CTRL1);
 789         if (ret < 0)
 790                 return ret;
 791
 792         ret |= DW_VR_MII_DIG_CTRL1_MAC_AUTO_SW;
 793
 794         return xpcs_write(xpcs, MDIO_MMD_VEND2, DW_VR_MII_DIG_CTRL1, ret);
 795 }
 796
 797 static int xpcs_config(struct mdio_xpcs_args *xpcs,
 798                        const struct phylink_link_state *state)
 799 {
 800         const struct xpcs_compat *compat;
 801         int ret;
 802
 803         compat = xpcs_find_compat(xpcs->id, state->interface);
 804         if (!compat)
 805                 return -ENODEV;
 806
 807         switch (compat->an_mode) {
 808         case DW_AN_C73:
 809                 if (state->an_enabled) {
 810                         ret = xpcs_config_aneg_c73(xpcs, compat);
 811                         if (ret)
 812                                 return ret;
 813                 }
 814                 break;
 815         case DW_AN_C37_SGMII:
 816                 ret = xpcs_config_aneg_c37_sgmii(xpcs);
 817                 if (ret)
 818                         return ret;
 819                 break;
 820         default:
 821                 return -1;
 822         }
 823
 824         return 0;
 825 }
 826
 827 static int xpcs_get_state_c73(struct mdio_xpcs_args *xpcs,
 828                               struct phylink_link_state *state,
 829                               const struct xpcs_compat *compat)
 830 {
 831         int ret;
 832
 833         /* Link needs to be read first ... */
 834         state->link = xpcs_read_link_c73(xpcs, state->an_enabled) > 0 ? 1 : 0;
 835
 836         /* ... and then we check the faults. */
 837         ret = xpcs_read_fault_c73(xpcs, state);
 838         if (ret) {
 839                 ret = xpcs_soft_reset(xpcs, compat);
 840                 if (ret)
 841                         return ret;
 842
 843                 state->link = 0;
 844
 845                 return xpcs_config(xpcs, state);
 846         }
 847
 848         if (state->an_enabled && xpcs_aneg_done_c73(xpcs, state, compat)) {
 849                 state->an_complete = true;
 850                 xpcs_read_lpa_c73(xpcs, state);
 851                 xpcs_resolve_lpa_c73(xpcs, state);
 852         } else if (state->an_enabled) {
 853                 state->link = 0;
 854         } else if (state->link) {
 855                 xpcs_resolve_pma(xpcs, state);
 856         }
 857
 858         return 0;
 859 }
 860
 861 static int xpcs_get_state_c37_sgmii(struct mdio_xpcs_args *xpcs,
 862                                     struct phylink_link_state *state)
 863 {
 864         int ret;
 865
 866         /* Reset link_state */
 867         state->link = false;
 868         state->speed = SPEED_UNKNOWN;
 869         state->duplex = DUPLEX_UNKNOWN;
 870         state->pause = 0;
 871
 872         /* For C37 SGMII mode, we check DW_VR_MII_AN_INTR_STS for link
 873          * status, speed and duplex.
 874          */
 875         ret = xpcs_read(xpcs, MDIO_MMD_VEND2, DW_VR_MII_AN_INTR_STS);
 876         if (ret < 0)
 877                 return false;
 878
 879         if (ret & DW_VR_MII_C37_ANSGM_SP_LNKSTS) {
 880                 int speed_value;
 881
 882                 state->link = true;
 883
 884                 speed_value = (ret & DW_VR_MII_AN_STS_C37_ANSGM_SP) >>
 885                               DW_VR_MII_AN_STS_C37_ANSGM_SP_SHIFT;
 886                 if (speed_value == DW_VR_MII_C37_ANSGM_SP_1000)
 887                         state->speed = SPEED_1000;
 888                 else if (speed_value == DW_VR_MII_C37_ANSGM_SP_100)
 889                         state->speed = SPEED_100;
 890                 else
 891                         state->speed = SPEED_10;
 892
 893                 if (ret & DW_VR_MII_AN_STS_C37_ANSGM_FD)
 894                         state->duplex = DUPLEX_FULL;
 895                 else
 896                         state->duplex = DUPLEX_HALF;
 897         }
 898
 899         return 0;
 900 }
 901
 902 static int xpcs_get_state(struct mdio_xpcs_args *xpcs,
 903                           struct phylink_link_state *state)
 904 {
 905         const struct xpcs_compat *compat;
 906         int ret;
 907
 908         compat = xpcs_find_compat(xpcs->id, state->interface);
 909         if (!compat)
 910                 return -ENODEV;
 911
 912         switch (compat->an_mode) {
 913         case DW_AN_C73:
 914                 ret = xpcs_get_state_c73(xpcs, state, compat);
 915                 if (ret)
 916                         return ret;
 917                 break;
 918         case DW_AN_C37_SGMII:
 919                 ret = xpcs_get_state_c37_sgmii(xpcs, state);
 920                 if (ret)
 921                         return ret;
 922                 break;
 923         default:
 924                 return -1;
 925         }
 926
 927         return 0;
 928 }
 929
 930 static int xpcs_link_up(struct mdio_xpcs_args *xpcs, int speed,
 931                         phy_interface_t interface)
 932 {
 933         if (interface == PHY_INTERFACE_MODE_USXGMII)
 934                 return xpcs_config_usxgmii(xpcs, speed);
 935
 936         return 0;
 937 }
 938
 939 static u32 xpcs_get_id(struct mdio_xpcs_args *xpcs)
 940 {
 941         int ret;
 942         u32 id;
 943
 944         /* First, search C73 PCS using PCS MMD */
 945         ret = xpcs_read(xpcs, MDIO_MMD_PCS, MII_PHYSID1);
 946         if (ret < 0)
 947                 return 0xffffffff;
 948
 949         id = ret << 16;
 950
 951         ret = xpcs_read(xpcs, MDIO_MMD_PCS, MII_PHYSID2);
 952         if (ret < 0)
 953                 return 0xffffffff;
 954
 955         /* If Device IDs are not all zeros, we found C73 AN-type device */
 956         if (id | ret)
 957                 return id | ret;
 958
 959         /* Next, search C37 PCS using Vendor-Specific MII MMD */
 960         ret = xpcs_read(xpcs, MDIO_MMD_VEND2, MII_PHYSID1);
 961         if (ret < 0)
 962                 return 0xffffffff;
 963
 964         id = ret << 16;
 965
 966         ret = xpcs_read(xpcs, MDIO_MMD_VEND2, MII_PHYSID2);
 967         if (ret < 0)
 968                 return 0xffffffff;
 969
 970         /* If Device IDs are not all zeros, we found C37 AN-type device */
 971         if (id | ret)
 972                 return id | ret;
 973
 974         return 0xffffffff;
 975 }
 976
 977 static const struct xpcs_compat synopsys_xpcs_compat[DW_XPCS_INTERFACE_MAX] = {
 978         [DW_XPCS_USXGMII] = {
 979                 .supported = xpcs_usxgmii_features,
 980                 .interface = xpcs_usxgmii_interfaces,
 981                 .num_interfaces = ARRAY_SIZE(xpcs_usxgmii_interfaces),
 982                 .an_mode = DW_AN_C73,
 983         },
 984         [DW_XPCS_10GKR] = {
 985                 .supported = xpcs_10gkr_features,
 986                 .interface = xpcs_10gkr_interfaces,
 987                 .num_interfaces = ARRAY_SIZE(xpcs_10gkr_interfaces),
 988                 .an_mode = DW_AN_C73,
 989         },
 990         [DW_XPCS_XLGMII] = {
 991                 .supported = xpcs_xlgmii_features,
 992                 .interface = xpcs_xlgmii_interfaces,
 993                 .num_interfaces = ARRAY_SIZE(xpcs_xlgmii_interfaces),
 994                 .an_mode = DW_AN_C73,
 995         },
 996         [DW_XPCS_SGMII] = {
 997                 .supported = xpcs_sgmii_features,
 998                 .interface = xpcs_sgmii_interfaces,
 999                 .num_interfaces = ARRAY_SIZE(xpcs_sgmii_interfaces),
1000                 .an_mode = DW_AN_C37_SGMII,
1001         },
1002 };
1003
1004 static const struct xpcs_id xpcs_id_list[] = {
1005         {
1006                 .id = SYNOPSYS_XPCS_ID,
1007                 .mask = SYNOPSYS_XPCS_MASK,
1008                 .compat = synopsys_xpcs_compat,
1009         },
1010 };
1011
1012 struct mdio_xpcs_args *xpcs_create(struct mdio_device *mdiodev,
1013                                    phy_interface_t interface)
1014 {
1015         struct mdio_xpcs_args *xpcs;
1016         u32 xpcs_id;
1017         int i, ret;
1018
1019         xpcs = kzalloc(sizeof(*xpcs), GFP_KERNEL);
1020         if (!xpcs)
1021                 return NULL;
1022
1023         xpcs->mdiodev = mdiodev;
1024
1025         xpcs_id = xpcs_get_id(xpcs);
1026
1027         for (i = 0; i < ARRAY_SIZE(xpcs_id_list); i++) {
1028                 const struct xpcs_id *entry = &xpcs_id_list[i];
1029                 const struct xpcs_compat *compat;
1030
1031                 if ((xpcs_id & entry->mask) != entry->id)
1032                         continue;
1033
1034                 xpcs->id = entry;
1035
1036                 compat = xpcs_find_compat(entry, interface);
1037                 if (!compat) {
1038                         ret = -ENODEV;
1039                         goto out;
1040                 }
1041
1042                 ret = xpcs_soft_reset(xpcs, compat);
1043                 if (ret)
1044                         goto out;
1045
1046                 return xpcs;
1047         }
1048
1049         ret = -ENODEV;
1050
1051 out:
1052         kfree(xpcs);
1053
1054         return ERR_PTR(ret);
1055 }
1056 EXPORT_SYMBOL_GPL(xpcs_create);
1057
1058 void xpcs_destroy(struct mdio_xpcs_args *xpcs)
1059 {
1060         kfree(xpcs);
1061 }
1062 EXPORT_SYMBOL_GPL(xpcs_destroy);
1063
1064 static struct mdio_xpcs_ops xpcs_ops = {
1065         .config = xpcs_config,
1066         .get_state = xpcs_get_state,
1067         .link_up = xpcs_link_up,
1068 };
1069
1070 struct mdio_xpcs_ops *mdio_xpcs_get_ops(void)
1071 {
1072         return &xpcs_ops;
1073 }
1074 EXPORT_SYMBOL_GPL(mdio_xpcs_get_ops);
1075
1076 MODULE_LICENSE("GPL v2");