drivers/net/axgbe/axgbe_mdio.c

   1 /*   SPDX-License-Identifier: BSD-3-Clause
   2  *   Copyright(c) 2018 Advanced Micro Devices, Inc. All rights reserved.
   3  *   Copyright(c) 2018 Synopsys, Inc. All rights reserved.
   4  */
   5
   6 #include "axgbe_ethdev.h"
   7 #include "axgbe_common.h"
   8 #include "axgbe_phy.h"
   9
  10 static void axgbe_an37_clear_interrupts(struct axgbe_port *pdata)
  11 {
  12         int reg;
  13
  14         reg = XMDIO_READ(pdata, MDIO_MMD_VEND2, MDIO_VEND2_AN_STAT);
  15         reg &= ~AXGBE_AN_CL37_INT_MASK;
  16         XMDIO_WRITE(pdata, MDIO_MMD_VEND2, MDIO_VEND2_AN_STAT, reg);
  17 }
  18
  19 static void axgbe_an37_disable_interrupts(struct axgbe_port *pdata)
  20 {
  21         int reg;
  22
  23         reg = XMDIO_READ(pdata, MDIO_MMD_VEND2, MDIO_VEND2_AN_CTRL);
  24         reg &= ~AXGBE_AN_CL37_INT_MASK;
  25         XMDIO_WRITE(pdata, MDIO_MMD_VEND2, MDIO_VEND2_AN_CTRL, reg);
  26
  27         reg = XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_PCS_DIG_CTRL);
  28         reg &= ~AXGBE_PCS_CL37_BP;
  29         XMDIO_WRITE(pdata, MDIO_MMD_PCS, MDIO_PCS_DIG_CTRL, reg);
  30 }
  31
  32 static void axgbe_an73_clear_interrupts(struct axgbe_port *pdata)
  33 {
  34         XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_INT, 0);
  35 }
  36
  37 static void axgbe_an73_disable_interrupts(struct axgbe_port *pdata)
  38 {
  39         XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_INTMASK, 0);
  40 }
  41
  42 static void axgbe_an73_enable_interrupts(struct axgbe_port *pdata)
  43 {
  44         XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_INTMASK,
  45                     AXGBE_AN_CL73_INT_MASK);
  46 }
  47
  48 static void axgbe_an_enable_interrupts(struct axgbe_port *pdata)
  49 {
  50         switch (pdata->an_mode) {
  51         case AXGBE_AN_MODE_CL73:
  52         case AXGBE_AN_MODE_CL73_REDRV:
  53                 axgbe_an73_enable_interrupts(pdata);
  54                 break;
  55         case AXGBE_AN_MODE_CL37:
  56         case AXGBE_AN_MODE_CL37_SGMII:
  57                 PMD_DRV_LOG(ERR, "Unsupported AN_MOD_37\n");
  58                 break;
  59         default:
  60                 break;
  61         }
  62 }
  63
  64 static void axgbe_an_clear_interrupts_all(struct axgbe_port *pdata)
  65 {
  66         axgbe_an73_clear_interrupts(pdata);
  67         axgbe_an37_clear_interrupts(pdata);
  68 }
  69
  70 static void axgbe_an73_enable_kr_training(struct axgbe_port *pdata)
  71 {
  72         unsigned int reg;
  73
  74         reg = XMDIO_READ(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_10GBR_PMD_CTRL);
  75
  76         reg |= AXGBE_KR_TRAINING_ENABLE;
  77         XMDIO_WRITE(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_10GBR_PMD_CTRL, reg);
  78 }
  79
  80 static void axgbe_an73_disable_kr_training(struct axgbe_port *pdata)
  81 {
  82         unsigned int reg;
  83
  84         reg = XMDIO_READ(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_10GBR_PMD_CTRL);
  85
  86         reg &= ~AXGBE_KR_TRAINING_ENABLE;
  87         XMDIO_WRITE(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_10GBR_PMD_CTRL, reg);
  88 }
  89
  90 static void axgbe_kr_mode(struct axgbe_port *pdata)
  91 {
  92         /* Enable KR training */
  93         axgbe_an73_enable_kr_training(pdata);
  94
  95         /* Set MAC to 10G speed */
  96         pdata->hw_if.set_speed(pdata, SPEED_10000);
  97
  98         /* Call PHY implementation support to complete rate change */
  99         pdata->phy_if.phy_impl.set_mode(pdata, AXGBE_MODE_KR);
 100 }
 101
 102 static void axgbe_kx_2500_mode(struct axgbe_port *pdata)
 103 {
 104         /* Disable KR training */
 105         axgbe_an73_disable_kr_training(pdata);
 106
 107         /* Set MAC to 2.5G speed */
 108         pdata->hw_if.set_speed(pdata, SPEED_2500);
 109
 110         /* Call PHY implementation support to complete rate change */
 111         pdata->phy_if.phy_impl.set_mode(pdata, AXGBE_MODE_KX_2500);
 112 }
 113
 114 static void axgbe_kx_1000_mode(struct axgbe_port *pdata)
 115 {
 116         /* Disable KR training */
 117         axgbe_an73_disable_kr_training(pdata);
 118
 119         /* Set MAC to 1G speed */
 120         pdata->hw_if.set_speed(pdata, SPEED_1000);
 121
 122         /* Call PHY implementation support to complete rate change */
 123         pdata->phy_if.phy_impl.set_mode(pdata, AXGBE_MODE_KX_1000);
 124 }
 125
 126 static void axgbe_sfi_mode(struct axgbe_port *pdata)
 127 {
 128         /* If a KR re-driver is present, change to KR mode instead */
 129         if (pdata->kr_redrv)
 130                 return axgbe_kr_mode(pdata);
 131
 132         /* Disable KR training */
 133         axgbe_an73_disable_kr_training(pdata);
 134
 135         /* Set MAC to 10G speed */
 136         pdata->hw_if.set_speed(pdata, SPEED_10000);
 137
 138         /* Call PHY implementation support to complete rate change */
 139         pdata->phy_if.phy_impl.set_mode(pdata, AXGBE_MODE_SFI);
 140 }
 141
 142 static void axgbe_x_mode(struct axgbe_port *pdata)
 143 {
 144         /* Disable KR training */
 145         axgbe_an73_disable_kr_training(pdata);
 146
 147         /* Set MAC to 1G speed */
 148         pdata->hw_if.set_speed(pdata, SPEED_1000);
 149
 150         /* Call PHY implementation support to complete rate change */
 151         pdata->phy_if.phy_impl.set_mode(pdata, AXGBE_MODE_X);
 152 }
 153
 154 static void axgbe_sgmii_1000_mode(struct axgbe_port *pdata)
 155 {
 156         /* Disable KR training */
 157         axgbe_an73_disable_kr_training(pdata);
 158
 159         /* Set MAC to 1G speed */
 160         pdata->hw_if.set_speed(pdata, SPEED_1000);
 161
 162         /* Call PHY implementation support to complete rate change */
 163         pdata->phy_if.phy_impl.set_mode(pdata, AXGBE_MODE_SGMII_1000);
 164 }
 165
 166 static void axgbe_sgmii_100_mode(struct axgbe_port *pdata)
 167 {
 168         /* Disable KR training */
 169         axgbe_an73_disable_kr_training(pdata);
 170
 171         /* Set MAC to 1G speed */
 172         pdata->hw_if.set_speed(pdata, SPEED_1000);
 173
 174         /* Call PHY implementation support to complete rate change */
 175         pdata->phy_if.phy_impl.set_mode(pdata, AXGBE_MODE_SGMII_100);
 176 }
 177
 178 static enum axgbe_mode axgbe_cur_mode(struct axgbe_port *pdata)
 179 {
 180         return pdata->phy_if.phy_impl.cur_mode(pdata);
 181 }
 182
 183 static bool axgbe_in_kr_mode(struct axgbe_port *pdata)
 184 {
 185         return axgbe_cur_mode(pdata) == AXGBE_MODE_KR;
 186 }
 187
 188 static void axgbe_change_mode(struct axgbe_port *pdata,
 189                               enum axgbe_mode mode)
 190 {
 191         switch (mode) {
 192         case AXGBE_MODE_KX_1000:
 193                 axgbe_kx_1000_mode(pdata);
 194                 break;
 195         case AXGBE_MODE_KX_2500:
 196                 axgbe_kx_2500_mode(pdata);
 197                 break;
 198         case AXGBE_MODE_KR:
 199                 axgbe_kr_mode(pdata);
 200                 break;
 201         case AXGBE_MODE_SGMII_100:
 202                 axgbe_sgmii_100_mode(pdata);
 203                 break;
 204         case AXGBE_MODE_SGMII_1000:
 205                 axgbe_sgmii_1000_mode(pdata);
 206                 break;
 207         case AXGBE_MODE_X:
 208                 axgbe_x_mode(pdata);
 209                 break;
 210         case AXGBE_MODE_SFI:
 211                 axgbe_sfi_mode(pdata);
 212                 break;
 213         case AXGBE_MODE_UNKNOWN:
 214                 break;
 215         default:
 216                 PMD_DRV_LOG(ERR, "invalid operation mode requested (%u)\n", mode);
 217         }
 218 }
 219
 220 static void axgbe_switch_mode(struct axgbe_port *pdata)
 221 {
 222         axgbe_change_mode(pdata, pdata->phy_if.phy_impl.switch_mode(pdata));
 223 }
 224
 225 static void axgbe_set_mode(struct axgbe_port *pdata,
 226                            enum axgbe_mode mode)
 227 {
 228         if (mode == axgbe_cur_mode(pdata))
 229                 return;
 230
 231         axgbe_change_mode(pdata, mode);
 232 }
 233
 234 static bool axgbe_use_mode(struct axgbe_port *pdata,
 235                            enum axgbe_mode mode)
 236 {
 237         return pdata->phy_if.phy_impl.use_mode(pdata, mode);
 238 }
 239
 240 static void axgbe_an37_set(struct axgbe_port *pdata, bool enable,
 241                            bool restart)
 242 {
 243         unsigned int reg;
 244
 245         reg = XMDIO_READ(pdata, MDIO_MMD_VEND2, MDIO_CTRL1);
 246         reg &= ~MDIO_VEND2_CTRL1_AN_ENABLE;
 247
 248         if (enable)
 249                 reg |= MDIO_VEND2_CTRL1_AN_ENABLE;
 250
 251         if (restart)
 252                 reg |= MDIO_VEND2_CTRL1_AN_RESTART;
 253
 254         XMDIO_WRITE(pdata, MDIO_MMD_VEND2, MDIO_CTRL1, reg);
 255 }
 256
 257 static void axgbe_an37_disable(struct axgbe_port *pdata)
 258 {
 259         axgbe_an37_set(pdata, false, false);
 260         axgbe_an37_disable_interrupts(pdata);
 261 }
 262
 263 static void axgbe_an73_set(struct axgbe_port *pdata, bool enable,
 264                            bool restart)
 265 {
 266         unsigned int reg;
 267
 268         reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_CTRL1);
 269         reg &= ~MDIO_AN_CTRL1_ENABLE;
 270
 271         if (enable)
 272                 reg |= MDIO_AN_CTRL1_ENABLE;
 273
 274         if (restart)
 275                 reg |= MDIO_AN_CTRL1_RESTART;
 276
 277         XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_CTRL1, reg);
 278 }
 279
 280 static void axgbe_an73_restart(struct axgbe_port *pdata)
 281 {
 282         axgbe_an73_enable_interrupts(pdata);
 283         axgbe_an73_set(pdata, true, true);
 284 }
 285
 286 static void axgbe_an73_disable(struct axgbe_port *pdata)
 287 {
 288         axgbe_an73_set(pdata, false, false);
 289         axgbe_an73_disable_interrupts(pdata);
 290 }
 291
 292 static void axgbe_an_restart(struct axgbe_port *pdata)
 293 {
 294         switch (pdata->an_mode) {
 295         case AXGBE_AN_MODE_CL73:
 296         case AXGBE_AN_MODE_CL73_REDRV:
 297                 axgbe_an73_restart(pdata);
 298                 break;
 299         case AXGBE_AN_MODE_CL37:
 300         case AXGBE_AN_MODE_CL37_SGMII:
 301                 PMD_DRV_LOG(ERR, "Unsupported AN_MODE_CL37\n");
 302                 break;
 303         default:
 304                 break;
 305         }
 306 }
 307
 308 static void axgbe_an_disable(struct axgbe_port *pdata)
 309 {
 310         switch (pdata->an_mode) {
 311         case AXGBE_AN_MODE_CL73:
 312         case AXGBE_AN_MODE_CL73_REDRV:
 313                 axgbe_an73_disable(pdata);
 314                 break;
 315         case AXGBE_AN_MODE_CL37:
 316         case AXGBE_AN_MODE_CL37_SGMII:
 317                 PMD_DRV_LOG(ERR, "Unsupported AN_MODE_CL37\n");
 318                 break;
 319         default:
 320                 break;
 321         }
 322 }
 323
 324 static void axgbe_an_disable_all(struct axgbe_port *pdata)
 325 {
 326         axgbe_an73_disable(pdata);
 327         axgbe_an37_disable(pdata);
 328 }
 329
 330 static enum axgbe_an axgbe_an73_tx_training(struct axgbe_port *pdata,
 331                                             enum axgbe_rx *state)
 332 {
 333         unsigned int ad_reg, lp_reg, reg;
 334
 335         *state = AXGBE_RX_COMPLETE;
 336
 337         /* If we're not in KR mode then we're done */
 338         if (!axgbe_in_kr_mode(pdata))
 339                 return AXGBE_AN_PAGE_RECEIVED;
 340
 341         /* Enable/Disable FEC */
 342         ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 2);
 343         lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA + 2);
 344
 345         reg = XMDIO_READ(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_10GBR_FECCTRL);
 346         reg &= ~(MDIO_PMA_10GBR_FECABLE_ABLE | MDIO_PMA_10GBR_FECABLE_ERRABLE);
 347         if ((ad_reg & 0xc000) && (lp_reg & 0xc000))
 348                 reg |= pdata->fec_ability;
 349         XMDIO_WRITE(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_10GBR_FECCTRL, reg);
 350
 351         /* Start KR training */
 352         reg = XMDIO_READ(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_10GBR_PMD_CTRL);
 353         if (reg & AXGBE_KR_TRAINING_ENABLE) {
 354                 if (pdata->phy_if.phy_impl.kr_training_pre)
 355                         pdata->phy_if.phy_impl.kr_training_pre(pdata);
 356
 357                 reg |= AXGBE_KR_TRAINING_START;
 358                 XMDIO_WRITE(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_10GBR_PMD_CTRL,
 359                             reg);
 360
 361                 if (pdata->phy_if.phy_impl.kr_training_post)
 362                         pdata->phy_if.phy_impl.kr_training_post(pdata);
 363         }
 364
 365         return AXGBE_AN_PAGE_RECEIVED;
 366 }
 367
 368 static enum axgbe_an axgbe_an73_tx_xnp(struct axgbe_port *pdata,
 369                                        enum axgbe_rx *state)
 370 {
 371         u16 msg;
 372
 373         *state = AXGBE_RX_XNP;
 374
 375         msg = AXGBE_XNP_MCF_NULL_MESSAGE;
 376         msg |= AXGBE_XNP_MP_FORMATTED;
 377
 378         XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_XNP + 2, 0);
 379         XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_XNP + 1, 0);
 380         XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_XNP, msg);
 381
 382         return AXGBE_AN_PAGE_RECEIVED;
 383 }
 384
 385 static enum axgbe_an axgbe_an73_rx_bpa(struct axgbe_port *pdata,
 386                                        enum axgbe_rx *state)
 387 {
 388         unsigned int link_support;
 389         unsigned int reg, ad_reg, lp_reg;
 390
 391         /* Read Base Ability register 2 first */
 392         reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA + 1);
 393
 394         /* Check for a supported mode, otherwise restart in a different one */
 395         link_support = axgbe_in_kr_mode(pdata) ? 0x80 : 0x20;
 396         if (!(reg & link_support))
 397                 return AXGBE_AN_INCOMPAT_LINK;
 398
 399         /* Check Extended Next Page support */
 400         ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE);
 401         lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA);
 402
 403         return ((ad_reg & AXGBE_XNP_NP_EXCHANGE) ||
 404                 (lp_reg & AXGBE_XNP_NP_EXCHANGE))
 405                 ? axgbe_an73_tx_xnp(pdata, state)
 406                 : axgbe_an73_tx_training(pdata, state);
 407 }
 408
 409 static enum axgbe_an axgbe_an73_rx_xnp(struct axgbe_port *pdata,
 410                                        enum axgbe_rx *state)
 411 {
 412         unsigned int ad_reg, lp_reg;
 413
 414         /* Check Extended Next Page support */
 415         ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_XNP);
 416         lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPX);
 417
 418         return ((ad_reg & AXGBE_XNP_NP_EXCHANGE) ||
 419                 (lp_reg & AXGBE_XNP_NP_EXCHANGE))
 420                 ? axgbe_an73_tx_xnp(pdata, state)
 421                 : axgbe_an73_tx_training(pdata, state);
 422 }
 423
 424 static enum axgbe_an axgbe_an73_page_received(struct axgbe_port *pdata)
 425 {
 426         enum axgbe_rx *state;
 427         unsigned long an_timeout;
 428         enum axgbe_an ret;
 429         unsigned long ticks;
 430
 431         if (!pdata->an_start) {
 432                 pdata->an_start = rte_get_timer_cycles();
 433         } else {
 434                 an_timeout = pdata->an_start +
 435                         msecs_to_timer_cycles(AXGBE_AN_MS_TIMEOUT);
 436                 ticks = rte_get_timer_cycles();
 437                 if (time_after(ticks, an_timeout)) {
 438                         /* Auto-negotiation timed out, reset state */
 439                         pdata->kr_state = AXGBE_RX_BPA;
 440                         pdata->kx_state = AXGBE_RX_BPA;
 441
 442                         pdata->an_start = rte_get_timer_cycles();
 443                 }
 444         }
 445
 446         state = axgbe_in_kr_mode(pdata) ? &pdata->kr_state
 447                 : &pdata->kx_state;
 448
 449         switch (*state) {
 450         case AXGBE_RX_BPA:
 451                 ret = axgbe_an73_rx_bpa(pdata, state);
 452                 break;
 453         case AXGBE_RX_XNP:
 454                 ret = axgbe_an73_rx_xnp(pdata, state);
 455                 break;
 456         default:
 457                 ret = AXGBE_AN_ERROR;
 458         }
 459
 460         return ret;
 461 }
 462
 463 static enum axgbe_an axgbe_an73_incompat_link(struct axgbe_port *pdata)
 464 {
 465         /* Be sure we aren't looping trying to negotiate */
 466         if (axgbe_in_kr_mode(pdata)) {
 467                 pdata->kr_state = AXGBE_RX_ERROR;
 468
 469                 if (!(pdata->phy.advertising & ADVERTISED_1000baseKX_Full) &&
 470                     !(pdata->phy.advertising & ADVERTISED_2500baseX_Full))
 471                         return AXGBE_AN_NO_LINK;
 472
 473                 if (pdata->kx_state != AXGBE_RX_BPA)
 474                         return AXGBE_AN_NO_LINK;
 475         } else {
 476                 pdata->kx_state = AXGBE_RX_ERROR;
 477
 478                 if (!(pdata->phy.advertising & ADVERTISED_10000baseKR_Full))
 479                         return AXGBE_AN_NO_LINK;
 480
 481                 if (pdata->kr_state != AXGBE_RX_BPA)
 482                         return AXGBE_AN_NO_LINK;
 483         }
 484
 485         axgbe_an73_disable(pdata);
 486         axgbe_switch_mode(pdata);
 487         axgbe_an73_restart(pdata);
 488
 489         return AXGBE_AN_INCOMPAT_LINK;
 490 }
 491
 492 static void axgbe_an73_state_machine(struct axgbe_port *pdata)
 493 {
 494         enum axgbe_an cur_state = pdata->an_state;
 495
 496         if (!pdata->an_int)
 497                 return;
 498
 499 next_int:
 500         if (pdata->an_int & AXGBE_AN_CL73_PG_RCV) {
 501                 pdata->an_state = AXGBE_AN_PAGE_RECEIVED;
 502                 pdata->an_int &= ~AXGBE_AN_CL73_PG_RCV;
 503         } else if (pdata->an_int & AXGBE_AN_CL73_INC_LINK) {
 504                 pdata->an_state = AXGBE_AN_INCOMPAT_LINK;
 505                 pdata->an_int &= ~AXGBE_AN_CL73_INC_LINK;
 506         } else if (pdata->an_int & AXGBE_AN_CL73_INT_CMPLT) {
 507                 pdata->an_state = AXGBE_AN_COMPLETE;
 508                 pdata->an_int &= ~AXGBE_AN_CL73_INT_CMPLT;
 509         } else {
 510                 pdata->an_state = AXGBE_AN_ERROR;
 511         }
 512
 513 again:
 514         cur_state = pdata->an_state;
 515
 516         switch (pdata->an_state) {
 517         case AXGBE_AN_READY:
 518                 pdata->an_supported = 0;
 519                 break;
 520         case AXGBE_AN_PAGE_RECEIVED:
 521                 pdata->an_state = axgbe_an73_page_received(pdata);
 522                 pdata->an_supported++;
 523                 break;
 524         case AXGBE_AN_INCOMPAT_LINK:
 525                 pdata->an_supported = 0;
 526                 pdata->parallel_detect = 0;
 527                 pdata->an_state = axgbe_an73_incompat_link(pdata);
 528                 break;
 529         case AXGBE_AN_COMPLETE:
 530                 pdata->parallel_detect = pdata->an_supported ? 0 : 1;
 531                 break;
 532         case AXGBE_AN_NO_LINK:
 533                 break;
 534         default:
 535                 pdata->an_state = AXGBE_AN_ERROR;
 536         }
 537
 538         if (pdata->an_state == AXGBE_AN_NO_LINK) {
 539                 pdata->an_int = 0;
 540                 axgbe_an73_clear_interrupts(pdata);
 541                 pdata->eth_dev->data->dev_link.link_status =
 542                         ETH_LINK_DOWN;
 543         } else if (pdata->an_state == AXGBE_AN_ERROR) {
 544                 PMD_DRV_LOG(ERR, "error during auto-negotiation, state=%u\n",
 545                             cur_state);
 546                 pdata->an_int = 0;
 547                 axgbe_an73_clear_interrupts(pdata);
 548         }
 549
 550         if (pdata->an_state >= AXGBE_AN_COMPLETE) {
 551                 pdata->an_result = pdata->an_state;
 552                 pdata->an_state = AXGBE_AN_READY;
 553                 pdata->kr_state = AXGBE_RX_BPA;
 554                 pdata->kx_state = AXGBE_RX_BPA;
 555                 pdata->an_start = 0;
 556         }
 557
 558         if (cur_state != pdata->an_state)
 559                 goto again;
 560
 561         if (pdata->an_int)
 562                 goto next_int;
 563
 564         axgbe_an73_enable_interrupts(pdata);
 565 }
 566
 567 static void axgbe_an73_isr(struct axgbe_port *pdata)
 568 {
 569         /* Disable AN interrupts */
 570         axgbe_an73_disable_interrupts(pdata);
 571
 572         /* Save the interrupt(s) that fired */
 573         pdata->an_int = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_INT);
 574
 575         if (pdata->an_int) {
 576                 /* Clear the interrupt(s) that fired and process them */
 577                 XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_INT, ~pdata->an_int);
 578                 pthread_mutex_lock(&pdata->an_mutex);
 579                 axgbe_an73_state_machine(pdata);
 580                 pthread_mutex_unlock(&pdata->an_mutex);
 581         } else {
 582                 /* Enable AN interrupts */
 583                 axgbe_an73_enable_interrupts(pdata);
 584         }
 585 }
 586
 587 static void axgbe_an_isr(struct axgbe_port *pdata)
 588 {
 589         switch (pdata->an_mode) {
 590         case AXGBE_AN_MODE_CL73:
 591         case AXGBE_AN_MODE_CL73_REDRV:
 592                 axgbe_an73_isr(pdata);
 593                 break;
 594         case AXGBE_AN_MODE_CL37:
 595         case AXGBE_AN_MODE_CL37_SGMII:
 596                 PMD_DRV_LOG(ERR, "AN_MODE_37 not supported\n");
 597                 break;
 598         default:
 599                 break;
 600         }
 601 }
 602
 603 static void axgbe_an_combined_isr(struct axgbe_port *pdata)
 604 {
 605         axgbe_an_isr(pdata);
 606 }
 607
 608 static void axgbe_an73_init(struct axgbe_port *pdata)
 609 {
 610         unsigned int advertising, reg;
 611
 612         advertising = pdata->phy_if.phy_impl.an_advertising(pdata);
 613
 614         /* Set up Advertisement register 3 first */
 615         reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 2);
 616         if (advertising & ADVERTISED_10000baseR_FEC)
 617                 reg |= 0xc000;
 618         else
 619                 reg &= ~0xc000;
 620
 621         XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 2, reg);
 622
 623         /* Set up Advertisement register 2 next */
 624         reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 1);
 625         if (advertising & ADVERTISED_10000baseKR_Full)
 626                 reg |= 0x80;
 627         else
 628                 reg &= ~0x80;
 629
 630         if ((advertising & ADVERTISED_1000baseKX_Full) ||
 631             (advertising & ADVERTISED_2500baseX_Full))
 632                 reg |= 0x20;
 633         else
 634                 reg &= ~0x20;
 635
 636         XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 1, reg);
 637
 638         /* Set up Advertisement register 1 last */
 639         reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE);
 640         if (advertising & ADVERTISED_Pause)
 641                 reg |= 0x400;
 642         else
 643                 reg &= ~0x400;
 644
 645         if (advertising & ADVERTISED_Asym_Pause)
 646                 reg |= 0x800;
 647         else
 648                 reg &= ~0x800;
 649
 650         /* We don't intend to perform XNP */
 651         reg &= ~AXGBE_XNP_NP_EXCHANGE;
 652
 653         XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE, reg);
 654 }
 655
 656 static void axgbe_an_init(struct axgbe_port *pdata)
 657 {
 658         /* Set up advertisement registers based on current settings */
 659         pdata->an_mode = pdata->phy_if.phy_impl.an_mode(pdata);
 660         switch (pdata->an_mode) {
 661         case AXGBE_AN_MODE_CL73:
 662         case AXGBE_AN_MODE_CL73_REDRV:
 663                 axgbe_an73_init(pdata);
 664                 break;
 665         case AXGBE_AN_MODE_CL37:
 666         case AXGBE_AN_MODE_CL37_SGMII:
 667                 PMD_DRV_LOG(ERR, "Unsupported AN_CL37\n");
 668                 break;
 669         default:
 670                 break;
 671         }
 672 }
 673
 674 static void axgbe_phy_adjust_link(struct axgbe_port *pdata)
 675 {
 676         if (pdata->phy.link) {
 677                 /* Flow control support */
 678                 pdata->pause_autoneg = pdata->phy.pause_autoneg;
 679
 680                 if (pdata->tx_pause != (unsigned int)pdata->phy.tx_pause) {
 681                         pdata->hw_if.config_tx_flow_control(pdata);
 682                         pdata->tx_pause = pdata->phy.tx_pause;
 683                 }
 684
 685                 if (pdata->rx_pause != (unsigned int)pdata->phy.rx_pause) {
 686                         pdata->hw_if.config_rx_flow_control(pdata);
 687                         pdata->rx_pause = pdata->phy.rx_pause;
 688                 }
 689
 690                 /* Speed support */
 691                 if (pdata->phy_speed != pdata->phy.speed)
 692                         pdata->phy_speed = pdata->phy.speed;
 693                 if (pdata->phy_link != pdata->phy.link)
 694                         pdata->phy_link = pdata->phy.link;
 695         } else if (pdata->phy_link) {
 696                 pdata->phy_link = 0;
 697                 pdata->phy_speed = SPEED_UNKNOWN;
 698         }
 699 }
 700
 701 static int axgbe_phy_config_fixed(struct axgbe_port *pdata)
 702 {
 703         enum axgbe_mode mode;
 704
 705         /* Disable auto-negotiation */
 706         axgbe_an_disable(pdata);
 707
 708         /* Set specified mode for specified speed */
 709         mode = pdata->phy_if.phy_impl.get_mode(pdata, pdata->phy.speed);
 710         switch (mode) {
 711         case AXGBE_MODE_KX_1000:
 712         case AXGBE_MODE_KX_2500:
 713         case AXGBE_MODE_KR:
 714         case AXGBE_MODE_SGMII_100:
 715         case AXGBE_MODE_SGMII_1000:
 716         case AXGBE_MODE_X:
 717         case AXGBE_MODE_SFI:
 718                 break;
 719         case AXGBE_MODE_UNKNOWN:
 720         default:
 721                 return -EINVAL;
 722         }
 723
 724         /* Validate duplex mode */
 725         if (pdata->phy.duplex != DUPLEX_FULL)
 726                 return -EINVAL;
 727
 728         axgbe_set_mode(pdata, mode);
 729
 730         return 0;
 731 }
 732
 733 static int __axgbe_phy_config_aneg(struct axgbe_port *pdata)
 734 {
 735         int ret;
 736
 737         axgbe_set_bit(AXGBE_LINK_INIT, &pdata->dev_state);
 738         pdata->link_check = rte_get_timer_cycles();
 739
 740         ret = pdata->phy_if.phy_impl.an_config(pdata);
 741         if (ret)
 742                 return ret;
 743
 744         if (pdata->phy.autoneg != AUTONEG_ENABLE) {
 745                 ret = axgbe_phy_config_fixed(pdata);
 746                 if (ret || !pdata->kr_redrv)
 747                         return ret;
 748         }
 749
 750         /* Disable auto-negotiation interrupt */
 751         rte_intr_disable(&pdata->pci_dev->intr_handle);
 752
 753         /* Start auto-negotiation in a supported mode */
 754         if (axgbe_use_mode(pdata, AXGBE_MODE_KR)) {
 755                 axgbe_set_mode(pdata, AXGBE_MODE_KR);
 756         } else if (axgbe_use_mode(pdata, AXGBE_MODE_KX_2500)) {
 757                 axgbe_set_mode(pdata, AXGBE_MODE_KX_2500);
 758         } else if (axgbe_use_mode(pdata, AXGBE_MODE_KX_1000)) {
 759                 axgbe_set_mode(pdata, AXGBE_MODE_KX_1000);
 760         } else if (axgbe_use_mode(pdata, AXGBE_MODE_SFI)) {
 761                 axgbe_set_mode(pdata, AXGBE_MODE_SFI);
 762         } else if (axgbe_use_mode(pdata, AXGBE_MODE_X)) {
 763                 axgbe_set_mode(pdata, AXGBE_MODE_X);
 764         } else if (axgbe_use_mode(pdata, AXGBE_MODE_SGMII_1000)) {
 765                 axgbe_set_mode(pdata, AXGBE_MODE_SGMII_1000);
 766         } else if (axgbe_use_mode(pdata, AXGBE_MODE_SGMII_100)) {
 767                 axgbe_set_mode(pdata, AXGBE_MODE_SGMII_100);
 768         } else {
 769                 rte_intr_enable(&pdata->pci_dev->intr_handle);
 770                 return -EINVAL;
 771         }
 772
 773         /* Disable and stop any in progress auto-negotiation */
 774         axgbe_an_disable_all(pdata);
 775
 776         /* Clear any auto-negotitation interrupts */
 777         axgbe_an_clear_interrupts_all(pdata);
 778
 779         pdata->an_result = AXGBE_AN_READY;
 780         pdata->an_state = AXGBE_AN_READY;
 781         pdata->kr_state = AXGBE_RX_BPA;
 782         pdata->kx_state = AXGBE_RX_BPA;
 783
 784         /* Re-enable auto-negotiation interrupt */
 785         rte_intr_enable(&pdata->pci_dev->intr_handle);
 786
 787         axgbe_an_init(pdata);
 788         axgbe_an_restart(pdata);
 789
 790         return 0;
 791 }
 792
 793 static int axgbe_phy_config_aneg(struct axgbe_port *pdata)
 794 {
 795         int ret;
 796
 797         pthread_mutex_lock(&pdata->an_mutex);
 798
 799         ret = __axgbe_phy_config_aneg(pdata);
 800         if (ret)
 801                 axgbe_set_bit(AXGBE_LINK_ERR, &pdata->dev_state);
 802         else
 803                 axgbe_clear_bit(AXGBE_LINK_ERR, &pdata->dev_state);
 804
 805         pthread_mutex_unlock(&pdata->an_mutex);
 806
 807         return ret;
 808 }
 809
 810 static bool axgbe_phy_aneg_done(struct axgbe_port *pdata)
 811 {
 812         return pdata->an_result == AXGBE_AN_COMPLETE;
 813 }
 814
 815 static void axgbe_check_link_timeout(struct axgbe_port *pdata)
 816 {
 817         unsigned long link_timeout;
 818         unsigned long ticks;
 819
 820         link_timeout = pdata->link_check + (AXGBE_LINK_TIMEOUT *
 821                                             2 *  rte_get_timer_hz());
 822         ticks = rte_get_timer_cycles();
 823         if (time_after(ticks, link_timeout))
 824                 axgbe_phy_config_aneg(pdata);
 825 }
 826
 827 static enum axgbe_mode axgbe_phy_status_aneg(struct axgbe_port *pdata)
 828 {
 829         return pdata->phy_if.phy_impl.an_outcome(pdata);
 830 }
 831
 832 static void axgbe_phy_status_result(struct axgbe_port *pdata)
 833 {
 834         enum axgbe_mode mode;
 835
 836         pdata->phy.lp_advertising = 0;
 837
 838         if ((pdata->phy.autoneg != AUTONEG_ENABLE) || pdata->parallel_detect)
 839                 mode = axgbe_cur_mode(pdata);
 840         else
 841                 mode = axgbe_phy_status_aneg(pdata);
 842
 843         switch (mode) {
 844         case AXGBE_MODE_SGMII_100:
 845                 pdata->phy.speed = SPEED_100;
 846                 break;
 847         case AXGBE_MODE_X:
 848         case AXGBE_MODE_KX_1000:
 849         case AXGBE_MODE_SGMII_1000:
 850                 pdata->phy.speed = SPEED_1000;
 851                 break;
 852         case AXGBE_MODE_KX_2500:
 853                 pdata->phy.speed = SPEED_2500;
 854                 break;
 855         case AXGBE_MODE_KR:
 856         case AXGBE_MODE_SFI:
 857                 pdata->phy.speed = SPEED_10000;
 858                 break;
 859         case AXGBE_MODE_UNKNOWN:
 860         default:
 861                 pdata->phy.speed = SPEED_UNKNOWN;
 862         }
 863
 864         pdata->phy.duplex = DUPLEX_FULL;
 865
 866         axgbe_set_mode(pdata, mode);
 867 }
 868
 869 static void axgbe_phy_status(struct axgbe_port *pdata)
 870 {
 871         unsigned int link_aneg;
 872         int an_restart;
 873
 874         if (axgbe_test_bit(AXGBE_LINK_ERR, &pdata->dev_state)) {
 875                 pdata->phy.link = 0;
 876                 goto adjust_link;
 877         }
 878
 879         link_aneg = (pdata->phy.autoneg == AUTONEG_ENABLE);
 880
 881         pdata->phy.link = pdata->phy_if.phy_impl.link_status(pdata,
 882                                                              &an_restart);
 883         if (an_restart) {
 884                 axgbe_phy_config_aneg(pdata);
 885                 return;
 886         }
 887
 888         if (pdata->phy.link) {
 889                 if (link_aneg && !axgbe_phy_aneg_done(pdata)) {
 890                         axgbe_check_link_timeout(pdata);
 891                         return;
 892                 }
 893                 axgbe_phy_status_result(pdata);
 894                 if (axgbe_test_bit(AXGBE_LINK_INIT, &pdata->dev_state))
 895                         axgbe_clear_bit(AXGBE_LINK_INIT, &pdata->dev_state);
 896         } else {
 897                 if (axgbe_test_bit(AXGBE_LINK_INIT, &pdata->dev_state)) {
 898                         axgbe_check_link_timeout(pdata);
 899
 900                         if (link_aneg)
 901                                 return;
 902                 }
 903                 axgbe_phy_status_result(pdata);
 904         }
 905
 906 adjust_link:
 907         axgbe_phy_adjust_link(pdata);
 908 }
 909
 910 static void axgbe_phy_stop(struct axgbe_port *pdata)
 911 {
 912         if (!pdata->phy_started)
 913                 return;
 914         /* Indicate the PHY is down */
 915         pdata->phy_started = 0;
 916         /* Disable auto-negotiation */
 917         axgbe_an_disable_all(pdata);
 918         pdata->phy_if.phy_impl.stop(pdata);
 919         pdata->phy.link = 0;
 920         axgbe_phy_adjust_link(pdata);
 921 }
 922
 923 static int axgbe_phy_start(struct axgbe_port *pdata)
 924 {
 925         int ret;
 926
 927         ret = pdata->phy_if.phy_impl.start(pdata);
 928         if (ret)
 929                 return ret;
 930         /* Set initial mode - call the mode setting routines
 931          * directly to insure we are properly configured
 932          */
 933         if (axgbe_use_mode(pdata, AXGBE_MODE_KR)) {
 934                 axgbe_kr_mode(pdata);
 935         } else if (axgbe_use_mode(pdata, AXGBE_MODE_KX_2500)) {
 936                 axgbe_kx_2500_mode(pdata);
 937         } else if (axgbe_use_mode(pdata, AXGBE_MODE_KX_1000)) {
 938                 axgbe_kx_1000_mode(pdata);
 939         } else if (axgbe_use_mode(pdata, AXGBE_MODE_SFI)) {
 940                 axgbe_sfi_mode(pdata);
 941         } else if (axgbe_use_mode(pdata, AXGBE_MODE_X)) {
 942                 axgbe_x_mode(pdata);
 943         } else if (axgbe_use_mode(pdata, AXGBE_MODE_SGMII_1000)) {
 944                 axgbe_sgmii_1000_mode(pdata);
 945         } else if (axgbe_use_mode(pdata, AXGBE_MODE_SGMII_100)) {
 946                 axgbe_sgmii_100_mode(pdata);
 947         } else {
 948                 ret = -EINVAL;
 949                 goto err_stop;
 950         }
 951         /* Indicate the PHY is up and running */
 952         pdata->phy_started = 1;
 953         axgbe_an_init(pdata);
 954         axgbe_an_enable_interrupts(pdata);
 955         return axgbe_phy_config_aneg(pdata);
 956
 957 err_stop:
 958         pdata->phy_if.phy_impl.stop(pdata);
 959
 960         return ret;
 961 }
 962
 963 static int axgbe_phy_reset(struct axgbe_port *pdata)
 964 {
 965         int ret;
 966
 967         ret = pdata->phy_if.phy_impl.reset(pdata);
 968         if (ret)
 969                 return ret;
 970
 971         /* Disable auto-negotiation for now */
 972         axgbe_an_disable_all(pdata);
 973
 974         /* Clear auto-negotiation interrupts */
 975         axgbe_an_clear_interrupts_all(pdata);
 976
 977         return 0;
 978 }
 979
 980 static int axgbe_phy_best_advertised_speed(struct axgbe_port *pdata)
 981 {
 982         if (pdata->phy.advertising & ADVERTISED_10000baseKR_Full)
 983                 return SPEED_10000;
 984         else if (pdata->phy.advertising & ADVERTISED_10000baseT_Full)
 985                 return SPEED_10000;
 986         else if (pdata->phy.advertising & ADVERTISED_2500baseX_Full)
 987                 return SPEED_2500;
 988         else if (pdata->phy.advertising & ADVERTISED_1000baseKX_Full)
 989                 return SPEED_1000;
 990         else if (pdata->phy.advertising & ADVERTISED_1000baseT_Full)
 991                 return SPEED_1000;
 992         else if (pdata->phy.advertising & ADVERTISED_100baseT_Full)
 993                 return SPEED_100;
 994
 995         return SPEED_UNKNOWN;
 996 }
 997
 998 static int axgbe_phy_init(struct axgbe_port *pdata)
 999 {
1000         int ret;
1001
1002         pdata->mdio_mmd = MDIO_MMD_PCS;
1003
1004         /* Check for FEC support */
1005         pdata->fec_ability = XMDIO_READ(pdata, MDIO_MMD_PMAPMD,
1006                                         MDIO_PMA_10GBR_FECABLE);
1007         pdata->fec_ability &= (MDIO_PMA_10GBR_FECABLE_ABLE |
1008                                MDIO_PMA_10GBR_FECABLE_ERRABLE);
1009
1010         /* Setup the phy (including supported features) */
1011         ret = pdata->phy_if.phy_impl.init(pdata);
1012         if (ret)
1013                 return ret;
1014         pdata->phy.advertising = pdata->phy.supported;
1015
1016         pdata->phy.address = 0;
1017
1018         if (pdata->phy.advertising & ADVERTISED_Autoneg) {
1019                 pdata->phy.autoneg = AUTONEG_ENABLE;
1020                 pdata->phy.speed = SPEED_UNKNOWN;
1021                 pdata->phy.duplex = DUPLEX_UNKNOWN;
1022         } else {
1023                 pdata->phy.autoneg = AUTONEG_DISABLE;
1024                 pdata->phy.speed = axgbe_phy_best_advertised_speed(pdata);
1025                 pdata->phy.duplex = DUPLEX_FULL;
1026         }
1027
1028         pdata->phy.link = 0;
1029
1030         pdata->phy.pause_autoneg = pdata->pause_autoneg;
1031         pdata->phy.tx_pause = pdata->tx_pause;
1032         pdata->phy.rx_pause = pdata->rx_pause;
1033
1034         /* Fix up Flow Control advertising */
1035         pdata->phy.advertising &= ~ADVERTISED_Pause;
1036         pdata->phy.advertising &= ~ADVERTISED_Asym_Pause;
1037
1038         if (pdata->rx_pause) {
1039                 pdata->phy.advertising |= ADVERTISED_Pause;
1040                 pdata->phy.advertising |= ADVERTISED_Asym_Pause;
1041         }
1042
1043         if (pdata->tx_pause)
1044                 pdata->phy.advertising ^= ADVERTISED_Asym_Pause;
1045         return 0;
1046 }
1047
1048 void axgbe_init_function_ptrs_phy(struct axgbe_phy_if *phy_if)
1049 {
1050         phy_if->phy_init        = axgbe_phy_init;
1051         phy_if->phy_reset       = axgbe_phy_reset;
1052         phy_if->phy_start       = axgbe_phy_start;
1053         phy_if->phy_stop        = axgbe_phy_stop;
1054         phy_if->phy_status      = axgbe_phy_status;
1055         phy_if->phy_config_aneg = axgbe_phy_config_aneg;
1056         phy_if->an_isr          = axgbe_an_combined_isr;
1057 }