drivers/net/txgbe/base/txgbe_phy.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2015-2020
   3  */
   4
   5 #include "txgbe_hw.h"
   6 #include "txgbe_eeprom.h"
   7 #include "txgbe_mng.h"
   8 #include "txgbe_phy.h"
   9
  10 static void txgbe_i2c_start(struct txgbe_hw *hw);
  11 static void txgbe_i2c_stop(struct txgbe_hw *hw);
  12 static s32 txgbe_handle_bp_flow(u32 link_mode, struct txgbe_hw *hw);
  13 static void txgbe_get_bp_ability(struct txgbe_backplane_ability *ability,
  14         u32 link_partner, struct txgbe_hw *hw);
  15 static s32 txgbe_check_bp_ability(struct txgbe_backplane_ability *local_ability,
  16         struct txgbe_backplane_ability *lp_ability, struct txgbe_hw *hw);
  17 static void txgbe_clear_bp_intr(u32 bit, u32 bit_high, struct txgbe_hw *hw);
  18 static s32 txgbe_enable_kr_training(struct txgbe_hw *hw);
  19 static s32 txgbe_disable_kr_training(struct txgbe_hw *hw, s32 post, s32 mode);
  20 static s32 txgbe_check_kr_training(struct txgbe_hw *hw);
  21 static void txgbe_read_phy_lane_tx_eq(u16 lane, struct txgbe_hw *hw,
  22                                 s32 post, s32 mode);
  23 static s32 txgbe_set_link_to_sfi(struct txgbe_hw *hw, u32 speed);
  24
  25 /**
  26  * txgbe_identify_extphy - Identify a single address for a PHY
  27  * @hw: pointer to hardware structure
  28  * @phy_addr: PHY address to probe
  29  *
  30  * Returns true if PHY found
  31  */
  32 static bool txgbe_identify_extphy(struct txgbe_hw *hw)
  33 {
  34         u16 phy_addr = 0;
  35
  36         if (!txgbe_validate_phy_addr(hw, phy_addr)) {
  37                 DEBUGOUT("Unable to validate PHY address 0x%04X\n",
  38                         phy_addr);
  39                 return false;
  40         }
  41
  42         if (txgbe_get_phy_id(hw))
  43                 return false;
  44
  45         hw->phy.type = txgbe_get_phy_type_from_id(hw->phy.id);
  46         if (hw->phy.type == txgbe_phy_unknown) {
  47                 u16 ext_ability = 0;
  48                 hw->phy.read_reg(hw, TXGBE_MD_PHY_EXT_ABILITY,
  49                                  TXGBE_MD_DEV_PMA_PMD,
  50                                  &ext_ability);
  51
  52                 if (ext_ability & (TXGBE_MD_PHY_10GBASET_ABILITY |
  53                         TXGBE_MD_PHY_1000BASET_ABILITY))
  54                         hw->phy.type = txgbe_phy_cu_unknown;
  55                 else
  56                         hw->phy.type = txgbe_phy_generic;
  57         }
  58
  59         return true;
  60 }
  61
  62 /**
  63  *  txgbe_read_phy_if - Read TXGBE_ETHPHYIF register
  64  *  @hw: pointer to hardware structure
  65  *
  66  *  Read TXGBE_ETHPHYIF register and save field values,
  67  *  and check for valid field values.
  68  **/
  69 static s32 txgbe_read_phy_if(struct txgbe_hw *hw)
  70 {
  71         hw->phy.media_type = hw->phy.get_media_type(hw);
  72
  73         /* Save NW management interface connected on board. This is used
  74          * to determine internal PHY mode.
  75          */
  76         hw->phy.nw_mng_if_sel = rd32(hw, TXGBE_ETHPHYIF);
  77
  78         /* If MDIO is connected to external PHY, then set PHY address. */
  79         if (hw->phy.nw_mng_if_sel & TXGBE_ETHPHYIF_MDIO_ACT)
  80                 hw->phy.addr = TXGBE_ETHPHYIF_MDIO_BASE(hw->phy.nw_mng_if_sel);
  81
  82         if (!hw->phy.phy_semaphore_mask) {
  83                 if (hw->bus.lan_id)
  84                         hw->phy.phy_semaphore_mask = TXGBE_MNGSEM_SWPHY;
  85                 else
  86                         hw->phy.phy_semaphore_mask = TXGBE_MNGSEM_SWPHY;
  87         }
  88
  89         return 0;
  90 }
  91
  92 /**
  93  *  txgbe_identify_phy - Get physical layer module
  94  *  @hw: pointer to hardware structure
  95  *
  96  *  Determines the physical layer module found on the current adapter.
  97  **/
  98 s32 txgbe_identify_phy(struct txgbe_hw *hw)
  99 {
 100         s32 err = TXGBE_ERR_PHY_ADDR_INVALID;
 101
 102         DEBUGFUNC("txgbe_identify_phy");
 103
 104         txgbe_read_phy_if(hw);
 105
 106         if (hw->phy.type != txgbe_phy_unknown)
 107                 return 0;
 108
 109         /* Raptor 10GBASE-T requires an external PHY */
 110         if (hw->phy.media_type == txgbe_media_type_copper) {
 111                 err = txgbe_identify_extphy(hw);
 112         } else if (hw->phy.media_type == txgbe_media_type_fiber) {
 113                 err = txgbe_identify_module(hw);
 114         } else {
 115                 hw->phy.type = txgbe_phy_none;
 116                 return 0;
 117         }
 118
 119         /* Return error if SFP module has been detected but is not supported */
 120         if (hw->phy.type == txgbe_phy_sfp_unsupported)
 121                 return TXGBE_ERR_SFP_NOT_SUPPORTED;
 122
 123         return err;
 124 }
 125
 126 /**
 127  * txgbe_check_reset_blocked - check status of MNG FW veto bit
 128  * @hw: pointer to the hardware structure
 129  *
 130  * This function checks the STAT.MNGVETO bit to see if there are
 131  * any constraints on link from manageability.  For MAC's that don't
 132  * have this bit just return faluse since the link can not be blocked
 133  * via this method.
 134  **/
 135 s32 txgbe_check_reset_blocked(struct txgbe_hw *hw)
 136 {
 137         u32 mmngc;
 138
 139         DEBUGFUNC("txgbe_check_reset_blocked");
 140
 141         mmngc = rd32(hw, TXGBE_STAT);
 142         if (mmngc & TXGBE_STAT_MNGVETO) {
 143                 DEBUGOUT("MNG_VETO bit detected.\n");
 144                 return true;
 145         }
 146
 147         return false;
 148 }
 149
 150 /**
 151  *  txgbe_validate_phy_addr - Determines phy address is valid
 152  *  @hw: pointer to hardware structure
 153  *  @phy_addr: PHY address
 154  *
 155  **/
 156 bool txgbe_validate_phy_addr(struct txgbe_hw *hw, u32 phy_addr)
 157 {
 158         u16 phy_id = 0;
 159         bool valid = false;
 160
 161         DEBUGFUNC("txgbe_validate_phy_addr");
 162
 163         hw->phy.addr = phy_addr;
 164         hw->phy.read_reg(hw, TXGBE_MD_PHY_ID_HIGH,
 165                              TXGBE_MD_DEV_PMA_PMD, &phy_id);
 166
 167         if (phy_id != 0xFFFF && phy_id != 0x0)
 168                 valid = true;
 169
 170         DEBUGOUT("PHY ID HIGH is 0x%04X\n", phy_id);
 171
 172         return valid;
 173 }
 174
 175 /**
 176  *  txgbe_get_phy_id - Get the phy type
 177  *  @hw: pointer to hardware structure
 178  *
 179  **/
 180 s32 txgbe_get_phy_id(struct txgbe_hw *hw)
 181 {
 182         u32 err;
 183         u16 phy_id_high = 0;
 184         u16 phy_id_low = 0;
 185
 186         DEBUGFUNC("txgbe_get_phy_id");
 187
 188         err = hw->phy.read_reg(hw, TXGBE_MD_PHY_ID_HIGH,
 189                                       TXGBE_MD_DEV_PMA_PMD,
 190                                       &phy_id_high);
 191
 192         if (err == 0) {
 193                 hw->phy.id = (u32)(phy_id_high << 16);
 194                 err = hw->phy.read_reg(hw, TXGBE_MD_PHY_ID_LOW,
 195                                               TXGBE_MD_DEV_PMA_PMD,
 196                                               &phy_id_low);
 197                 hw->phy.id |= (u32)(phy_id_low & TXGBE_PHY_REVISION_MASK);
 198                 hw->phy.revision = (u32)(phy_id_low & ~TXGBE_PHY_REVISION_MASK);
 199         }
 200         DEBUGOUT("PHY_ID_HIGH 0x%04X, PHY_ID_LOW 0x%04X\n",
 201                   phy_id_high, phy_id_low);
 202
 203         return err;
 204 }
 205
 206 /**
 207  *  txgbe_get_phy_type_from_id - Get the phy type
 208  *  @phy_id: PHY ID information
 209  *
 210  **/
 211 enum txgbe_phy_type txgbe_get_phy_type_from_id(u32 phy_id)
 212 {
 213         enum txgbe_phy_type phy_type;
 214
 215         DEBUGFUNC("txgbe_get_phy_type_from_id");
 216
 217         switch (phy_id) {
 218         case TXGBE_PHYID_TN1010:
 219                 phy_type = txgbe_phy_tn;
 220                 break;
 221         case TXGBE_PHYID_QT2022:
 222                 phy_type = txgbe_phy_qt;
 223                 break;
 224         case TXGBE_PHYID_ATH:
 225                 phy_type = txgbe_phy_nl;
 226                 break;
 227         case TXGBE_PHYID_MTD3310:
 228                 phy_type = txgbe_phy_cu_mtd;
 229                 break;
 230         default:
 231                 phy_type = txgbe_phy_unknown;
 232                 break;
 233         }
 234
 235         return phy_type;
 236 }
 237
 238 static s32
 239 txgbe_reset_extphy(struct txgbe_hw *hw)
 240 {
 241         u16 ctrl = 0;
 242         int err, i;
 243
 244         err = hw->phy.read_reg(hw, TXGBE_MD_PORT_CTRL,
 245                         TXGBE_MD_DEV_GENERAL, &ctrl);
 246         if (err != 0)
 247                 return err;
 248         ctrl |= TXGBE_MD_PORT_CTRL_RESET;
 249         err = hw->phy.write_reg(hw, TXGBE_MD_PORT_CTRL,
 250                         TXGBE_MD_DEV_GENERAL, ctrl);
 251         if (err != 0)
 252                 return err;
 253
 254         /*
 255          * Poll for reset bit to self-clear indicating reset is complete.
 256          * Some PHYs could take up to 3 seconds to complete and need about
 257          * 1.7 usec delay after the reset is complete.
 258          */
 259         for (i = 0; i < 30; i++) {
 260                 msec_delay(100);
 261                 err = hw->phy.read_reg(hw, TXGBE_MD_PORT_CTRL,
 262                         TXGBE_MD_DEV_GENERAL, &ctrl);
 263                 if (err != 0)
 264                         return err;
 265
 266                 if (!(ctrl & TXGBE_MD_PORT_CTRL_RESET)) {
 267                         usec_delay(2);
 268                         break;
 269                 }
 270         }
 271
 272         if (ctrl & TXGBE_MD_PORT_CTRL_RESET) {
 273                 err = TXGBE_ERR_RESET_FAILED;
 274                 DEBUGOUT("PHY reset polling failed to complete.\n");
 275         }
 276
 277         return err;
 278 }
 279
 280 /**
 281  *  txgbe_reset_phy - Performs a PHY reset
 282  *  @hw: pointer to hardware structure
 283  **/
 284 s32 txgbe_reset_phy(struct txgbe_hw *hw)
 285 {
 286         s32 err = 0;
 287
 288         DEBUGFUNC("txgbe_reset_phy");
 289
 290         if (hw->phy.type == txgbe_phy_unknown)
 291                 err = txgbe_identify_phy(hw);
 292
 293         if (err != 0 || hw->phy.type == txgbe_phy_none)
 294                 return err;
 295
 296         /* Don't reset PHY if it's shut down due to overtemp. */
 297         if (hw->phy.check_overtemp(hw) == TXGBE_ERR_OVERTEMP)
 298                 return err;
 299
 300         /* Blocked by MNG FW so bail */
 301         if (txgbe_check_reset_blocked(hw))
 302                 return err;
 303
 304         switch (hw->phy.type) {
 305         case txgbe_phy_cu_mtd:
 306                 err = txgbe_reset_extphy(hw);
 307                 break;
 308         default:
 309                 break;
 310         }
 311
 312         return err;
 313 }
 314
 315 /**
 316  *  txgbe_read_phy_mdi - Reads a value from a specified PHY register without
 317  *  the SWFW lock
 318  *  @hw: pointer to hardware structure
 319  *  @reg_addr: 32 bit address of PHY register to read
 320  *  @device_type: 5 bit device type
 321  *  @phy_data: Pointer to read data from PHY register
 322  **/
 323 s32 txgbe_read_phy_reg_mdi(struct txgbe_hw *hw, u32 reg_addr, u32 device_type,
 324                            u16 *phy_data)
 325 {
 326         u32 command, data;
 327
 328         /* Setup and write the address cycle command */
 329         command = TXGBE_MDIOSCA_REG(reg_addr) |
 330                   TXGBE_MDIOSCA_DEV(device_type) |
 331                   TXGBE_MDIOSCA_PORT(hw->phy.addr);
 332         wr32(hw, TXGBE_MDIOSCA, command);
 333
 334         command = TXGBE_MDIOSCD_CMD_READ |
 335                   TXGBE_MDIOSCD_BUSY;
 336         wr32(hw, TXGBE_MDIOSCD, command);
 337
 338         /*
 339          * Check every 10 usec to see if the address cycle completed.
 340          * The MDI Command bit will clear when the operation is
 341          * complete
 342          */
 343         if (!po32m(hw, TXGBE_MDIOSCD, TXGBE_MDIOSCD_BUSY,
 344                 0, NULL, 100, 100)) {
 345                 DEBUGOUT("PHY address command did not complete\n");
 346                 return TXGBE_ERR_PHY;
 347         }
 348
 349         data = rd32(hw, TXGBE_MDIOSCD);
 350         *phy_data = (u16)TXGBD_MDIOSCD_DAT(data);
 351
 352         return 0;
 353 }
 354
 355 /**
 356  *  txgbe_read_phy_reg - Reads a value from a specified PHY register
 357  *  using the SWFW lock - this function is needed in most cases
 358  *  @hw: pointer to hardware structure
 359  *  @reg_addr: 32 bit address of PHY register to read
 360  *  @device_type: 5 bit device type
 361  *  @phy_data: Pointer to read data from PHY register
 362  **/
 363 s32 txgbe_read_phy_reg(struct txgbe_hw *hw, u32 reg_addr,
 364                                u32 device_type, u16 *phy_data)
 365 {
 366         s32 err;
 367         u32 gssr = hw->phy.phy_semaphore_mask;
 368
 369         DEBUGFUNC("txgbe_read_phy_reg");
 370
 371         if (hw->mac.acquire_swfw_sync(hw, gssr))
 372                 return TXGBE_ERR_SWFW_SYNC;
 373
 374         err = hw->phy.read_reg_mdi(hw, reg_addr, device_type, phy_data);
 375
 376         hw->mac.release_swfw_sync(hw, gssr);
 377
 378         return err;
 379 }
 380
 381 /**
 382  *  txgbe_write_phy_reg_mdi - Writes a value to specified PHY register
 383  *  without SWFW lock
 384  *  @hw: pointer to hardware structure
 385  *  @reg_addr: 32 bit PHY register to write
 386  *  @device_type: 5 bit device type
 387  *  @phy_data: Data to write to the PHY register
 388  **/
 389 s32 txgbe_write_phy_reg_mdi(struct txgbe_hw *hw, u32 reg_addr,
 390                                 u32 device_type, u16 phy_data)
 391 {
 392         u32 command;
 393
 394         /* write command */
 395         command = TXGBE_MDIOSCA_REG(reg_addr) |
 396                   TXGBE_MDIOSCA_DEV(device_type) |
 397                   TXGBE_MDIOSCA_PORT(hw->phy.addr);
 398         wr32(hw, TXGBE_MDIOSCA, command);
 399
 400         command = TXGBE_MDIOSCD_CMD_WRITE |
 401                   TXGBE_MDIOSCD_DAT(phy_data) |
 402                   TXGBE_MDIOSCD_BUSY;
 403         wr32(hw, TXGBE_MDIOSCD, command);
 404
 405         /* wait for completion */
 406         if (!po32m(hw, TXGBE_MDIOSCD, TXGBE_MDIOSCD_BUSY,
 407                 0, NULL, 100, 100)) {
 408                 TLOG_DEBUG("PHY write cmd didn't complete\n");
 409                 return -TERR_PHY;
 410         }
 411
 412         return 0;
 413 }
 414
 415 /**
 416  *  txgbe_write_phy_reg - Writes a value to specified PHY register
 417  *  using SWFW lock- this function is needed in most cases
 418  *  @hw: pointer to hardware structure
 419  *  @reg_addr: 32 bit PHY register to write
 420  *  @device_type: 5 bit device type
 421  *  @phy_data: Data to write to the PHY register
 422  **/
 423 s32 txgbe_write_phy_reg(struct txgbe_hw *hw, u32 reg_addr,
 424                                 u32 device_type, u16 phy_data)
 425 {
 426         s32 err;
 427         u32 gssr = hw->phy.phy_semaphore_mask;
 428
 429         DEBUGFUNC("txgbe_write_phy_reg");
 430
 431         if (hw->mac.acquire_swfw_sync(hw, gssr))
 432                 err = TXGBE_ERR_SWFW_SYNC;
 433
 434         err = hw->phy.write_reg_mdi(hw, reg_addr, device_type,
 435                                          phy_data);
 436         hw->mac.release_swfw_sync(hw, gssr);
 437
 438         return err;
 439 }
 440
 441 /**
 442  *  txgbe_setup_phy_link - Set and restart auto-neg
 443  *  @hw: pointer to hardware structure
 444  *
 445  *  Restart auto-negotiation and PHY and waits for completion.
 446  **/
 447 s32 txgbe_setup_phy_link(struct txgbe_hw *hw)
 448 {
 449         s32 err = 0;
 450         u16 autoneg_reg = TXGBE_MII_AUTONEG_REG;
 451         bool autoneg = false;
 452         u32 speed;
 453
 454         DEBUGFUNC("txgbe_setup_phy_link");
 455
 456         txgbe_get_copper_link_capabilities(hw, &speed, &autoneg);
 457
 458         /* Set or unset auto-negotiation 10G advertisement */
 459         hw->phy.read_reg(hw, TXGBE_MII_10GBASE_T_AUTONEG_CTRL_REG,
 460                              TXGBE_MD_DEV_AUTO_NEG,
 461                              &autoneg_reg);
 462
 463         autoneg_reg &= ~TXGBE_MII_10GBASE_T_ADVERTISE;
 464         if ((hw->phy.autoneg_advertised & TXGBE_LINK_SPEED_10GB_FULL) &&
 465             (speed & TXGBE_LINK_SPEED_10GB_FULL))
 466                 autoneg_reg |= TXGBE_MII_10GBASE_T_ADVERTISE;
 467
 468         hw->phy.write_reg(hw, TXGBE_MII_10GBASE_T_AUTONEG_CTRL_REG,
 469                               TXGBE_MD_DEV_AUTO_NEG,
 470                               autoneg_reg);
 471
 472         hw->phy.read_reg(hw, TXGBE_MII_AUTONEG_VENDOR_PROVISION_1_REG,
 473                              TXGBE_MD_DEV_AUTO_NEG,
 474                              &autoneg_reg);
 475
 476         /* Set or unset auto-negotiation 5G advertisement */
 477         autoneg_reg &= ~TXGBE_MII_5GBASE_T_ADVERTISE;
 478         if ((hw->phy.autoneg_advertised & TXGBE_LINK_SPEED_5GB_FULL) &&
 479             (speed & TXGBE_LINK_SPEED_5GB_FULL))
 480                 autoneg_reg |= TXGBE_MII_5GBASE_T_ADVERTISE;
 481
 482         /* Set or unset auto-negotiation 2.5G advertisement */
 483         autoneg_reg &= ~TXGBE_MII_2_5GBASE_T_ADVERTISE;
 484         if ((hw->phy.autoneg_advertised &
 485              TXGBE_LINK_SPEED_2_5GB_FULL) &&
 486             (speed & TXGBE_LINK_SPEED_2_5GB_FULL))
 487                 autoneg_reg |= TXGBE_MII_2_5GBASE_T_ADVERTISE;
 488         /* Set or unset auto-negotiation 1G advertisement */
 489         autoneg_reg &= ~TXGBE_MII_1GBASE_T_ADVERTISE;
 490         if ((hw->phy.autoneg_advertised & TXGBE_LINK_SPEED_1GB_FULL) &&
 491             (speed & TXGBE_LINK_SPEED_1GB_FULL))
 492                 autoneg_reg |= TXGBE_MII_1GBASE_T_ADVERTISE;
 493
 494         hw->phy.write_reg(hw, TXGBE_MII_AUTONEG_VENDOR_PROVISION_1_REG,
 495                               TXGBE_MD_DEV_AUTO_NEG,
 496                               autoneg_reg);
 497
 498         /* Set or unset auto-negotiation 100M advertisement */
 499         hw->phy.read_reg(hw, TXGBE_MII_AUTONEG_ADVERTISE_REG,
 500                              TXGBE_MD_DEV_AUTO_NEG,
 501                              &autoneg_reg);
 502
 503         autoneg_reg &= ~(TXGBE_MII_100BASE_T_ADVERTISE |
 504                          TXGBE_MII_100BASE_T_ADVERTISE_HALF);
 505         if ((hw->phy.autoneg_advertised & TXGBE_LINK_SPEED_100M_FULL) &&
 506             (speed & TXGBE_LINK_SPEED_100M_FULL))
 507                 autoneg_reg |= TXGBE_MII_100BASE_T_ADVERTISE;
 508
 509         hw->phy.write_reg(hw, TXGBE_MII_AUTONEG_ADVERTISE_REG,
 510                               TXGBE_MD_DEV_AUTO_NEG,
 511                               autoneg_reg);
 512
 513         /* Blocked by MNG FW so don't reset PHY */
 514         if (txgbe_check_reset_blocked(hw))
 515                 return err;
 516
 517         /* Restart PHY auto-negotiation. */
 518         hw->phy.read_reg(hw, TXGBE_MD_AUTO_NEG_CONTROL,
 519                              TXGBE_MD_DEV_AUTO_NEG, &autoneg_reg);
 520
 521         autoneg_reg |= TXGBE_MII_RESTART;
 522
 523         hw->phy.write_reg(hw, TXGBE_MD_AUTO_NEG_CONTROL,
 524                               TXGBE_MD_DEV_AUTO_NEG, autoneg_reg);
 525
 526         return err;
 527 }
 528
 529 /**
 530  *  txgbe_setup_phy_link_speed - Sets the auto advertised capabilities
 531  *  @hw: pointer to hardware structure
 532  *  @speed: new link speed
 533  *  @autoneg_wait_to_complete: unused
 534  **/
 535 s32 txgbe_setup_phy_link_speed(struct txgbe_hw *hw,
 536                                        u32 speed,
 537                                        bool autoneg_wait_to_complete)
 538 {
 539         UNREFERENCED_PARAMETER(autoneg_wait_to_complete);
 540
 541         DEBUGFUNC("txgbe_setup_phy_link_speed");
 542
 543         /*
 544          * Clear autoneg_advertised and set new values based on input link
 545          * speed.
 546          */
 547         hw->phy.autoneg_advertised = 0;
 548
 549         if (speed & TXGBE_LINK_SPEED_10GB_FULL)
 550                 hw->phy.autoneg_advertised |= TXGBE_LINK_SPEED_10GB_FULL;
 551
 552         if (speed & TXGBE_LINK_SPEED_5GB_FULL)
 553                 hw->phy.autoneg_advertised |= TXGBE_LINK_SPEED_5GB_FULL;
 554
 555         if (speed & TXGBE_LINK_SPEED_2_5GB_FULL)
 556                 hw->phy.autoneg_advertised |= TXGBE_LINK_SPEED_2_5GB_FULL;
 557
 558         if (speed & TXGBE_LINK_SPEED_1GB_FULL)
 559                 hw->phy.autoneg_advertised |= TXGBE_LINK_SPEED_1GB_FULL;
 560
 561         if (speed & TXGBE_LINK_SPEED_100M_FULL)
 562                 hw->phy.autoneg_advertised |= TXGBE_LINK_SPEED_100M_FULL;
 563
 564         if (speed & TXGBE_LINK_SPEED_10M_FULL)
 565                 hw->phy.autoneg_advertised |= TXGBE_LINK_SPEED_10M_FULL;
 566
 567         /* Setup link based on the new speed settings */
 568         hw->phy.setup_link(hw);
 569
 570         return 0;
 571 }
 572
 573 s32 txgbe_get_phy_fw_version(struct txgbe_hw *hw, u32 *fw_version)
 574 {
 575         u16 eeprom_verh, eeprom_verl;
 576
 577         hw->rom.readw_sw(hw, TXGBE_EEPROM_VERSION_H, &eeprom_verh);
 578         hw->rom.readw_sw(hw, TXGBE_EEPROM_VERSION_L, &eeprom_verl);
 579
 580         *fw_version = (eeprom_verh << 16) | eeprom_verl;
 581
 582         return 0;
 583 }
 584
 585 /**
 586  * txgbe_get_copper_speeds_supported - Get copper link speeds from phy
 587  * @hw: pointer to hardware structure
 588  *
 589  * Determines the supported link capabilities by reading the PHY auto
 590  * negotiation register.
 591  **/
 592 static s32 txgbe_get_copper_speeds_supported(struct txgbe_hw *hw)
 593 {
 594         s32 err;
 595         u16 speed_ability;
 596
 597         err = hw->phy.read_reg(hw, TXGBE_MD_PHY_SPEED_ABILITY,
 598                                       TXGBE_MD_DEV_PMA_PMD,
 599                                       &speed_ability);
 600         if (err)
 601                 return err;
 602
 603         if (speed_ability & TXGBE_MD_PHY_SPEED_10G)
 604                 hw->phy.speeds_supported |= TXGBE_LINK_SPEED_10GB_FULL;
 605         if (speed_ability & TXGBE_MD_PHY_SPEED_1G)
 606                 hw->phy.speeds_supported |= TXGBE_LINK_SPEED_1GB_FULL;
 607         if (speed_ability & TXGBE_MD_PHY_SPEED_100M)
 608                 hw->phy.speeds_supported |= TXGBE_LINK_SPEED_100M_FULL;
 609
 610         return err;
 611 }
 612
 613 /**
 614  *  txgbe_get_copper_link_capabilities - Determines link capabilities
 615  *  @hw: pointer to hardware structure
 616  *  @speed: pointer to link speed
 617  *  @autoneg: boolean auto-negotiation value
 618  **/
 619 s32 txgbe_get_copper_link_capabilities(struct txgbe_hw *hw,
 620                                                u32 *speed,
 621                                                bool *autoneg)
 622 {
 623         s32 err = 0;
 624
 625         DEBUGFUNC("txgbe_get_copper_link_capabilities");
 626
 627         *autoneg = true;
 628         if (!hw->phy.speeds_supported)
 629                 err = txgbe_get_copper_speeds_supported(hw);
 630
 631         *speed = hw->phy.speeds_supported;
 632         return err;
 633 }
 634
 635 /**
 636  *  txgbe_check_phy_link_tnx - Determine link and speed status
 637  *  @hw: pointer to hardware structure
 638  *  @speed: current link speed
 639  *  @link_up: true is link is up, false otherwise
 640  *
 641  *  Reads the VS1 register to determine if link is up and the current speed for
 642  *  the PHY.
 643  **/
 644 s32 txgbe_check_phy_link_tnx(struct txgbe_hw *hw, u32 *speed,
 645                              bool *link_up)
 646 {
 647         s32 err = 0;
 648         u32 time_out;
 649         u32 max_time_out = 10;
 650         u16 phy_link = 0;
 651         u16 phy_speed = 0;
 652         u16 phy_data = 0;
 653
 654         DEBUGFUNC("txgbe_check_phy_link_tnx");
 655
 656         /* Initialize speed and link to default case */
 657         *link_up = false;
 658         *speed = TXGBE_LINK_SPEED_10GB_FULL;
 659
 660         /*
 661          * Check current speed and link status of the PHY register.
 662          * This is a vendor specific register and may have to
 663          * be changed for other copper PHYs.
 664          */
 665         for (time_out = 0; time_out < max_time_out; time_out++) {
 666                 usec_delay(10);
 667                 err = hw->phy.read_reg(hw,
 668                                         TXGBE_MD_VENDOR_SPECIFIC_1_STATUS,
 669                                         TXGBE_MD_DEV_VENDOR_1,
 670                                         &phy_data);
 671                 phy_link = phy_data & TXGBE_MD_VENDOR_SPECIFIC_1_LINK_STATUS;
 672                 phy_speed = phy_data &
 673                                  TXGBE_MD_VENDOR_SPECIFIC_1_SPEED_STATUS;
 674                 if (phy_link == TXGBE_MD_VENDOR_SPECIFIC_1_LINK_STATUS) {
 675                         *link_up = true;
 676                         if (phy_speed ==
 677                             TXGBE_MD_VENDOR_SPECIFIC_1_SPEED_STATUS)
 678                                 *speed = TXGBE_LINK_SPEED_1GB_FULL;
 679                         break;
 680                 }
 681         }
 682
 683         return err;
 684 }
 685
 686 /**
 687  *  txgbe_setup_phy_link_tnx - Set and restart auto-neg
 688  *  @hw: pointer to hardware structure
 689  *
 690  *  Restart auto-negotiation and PHY and waits for completion.
 691  **/
 692 s32 txgbe_setup_phy_link_tnx(struct txgbe_hw *hw)
 693 {
 694         s32 err = 0;
 695         u16 autoneg_reg = TXGBE_MII_AUTONEG_REG;
 696         bool autoneg = false;
 697         u32 speed;
 698
 699         DEBUGFUNC("txgbe_setup_phy_link_tnx");
 700
 701         txgbe_get_copper_link_capabilities(hw, &speed, &autoneg);
 702
 703         if (speed & TXGBE_LINK_SPEED_10GB_FULL) {
 704                 /* Set or unset auto-negotiation 10G advertisement */
 705                 hw->phy.read_reg(hw, TXGBE_MII_10GBASE_T_AUTONEG_CTRL_REG,
 706                                      TXGBE_MD_DEV_AUTO_NEG,
 707                                      &autoneg_reg);
 708
 709                 autoneg_reg &= ~TXGBE_MII_10GBASE_T_ADVERTISE;
 710                 if (hw->phy.autoneg_advertised & TXGBE_LINK_SPEED_10GB_FULL)
 711                         autoneg_reg |= TXGBE_MII_10GBASE_T_ADVERTISE;
 712
 713                 hw->phy.write_reg(hw, TXGBE_MII_10GBASE_T_AUTONEG_CTRL_REG,
 714                                       TXGBE_MD_DEV_AUTO_NEG,
 715                                       autoneg_reg);
 716         }
 717
 718         if (speed & TXGBE_LINK_SPEED_1GB_FULL) {
 719                 /* Set or unset auto-negotiation 1G advertisement */
 720                 hw->phy.read_reg(hw, TXGBE_MII_AUTONEG_XNP_TX_REG,
 721                                      TXGBE_MD_DEV_AUTO_NEG,
 722                                      &autoneg_reg);
 723
 724                 autoneg_reg &= ~TXGBE_MII_1GBASE_T_ADVERTISE_XNP_TX;
 725                 if (hw->phy.autoneg_advertised & TXGBE_LINK_SPEED_1GB_FULL)
 726                         autoneg_reg |= TXGBE_MII_1GBASE_T_ADVERTISE_XNP_TX;
 727
 728                 hw->phy.write_reg(hw, TXGBE_MII_AUTONEG_XNP_TX_REG,
 729                                       TXGBE_MD_DEV_AUTO_NEG,
 730                                       autoneg_reg);
 731         }
 732
 733         if (speed & TXGBE_LINK_SPEED_100M_FULL) {
 734                 /* Set or unset auto-negotiation 100M advertisement */
 735                 hw->phy.read_reg(hw, TXGBE_MII_AUTONEG_ADVERTISE_REG,
 736                                      TXGBE_MD_DEV_AUTO_NEG,
 737                                      &autoneg_reg);
 738
 739                 autoneg_reg &= ~TXGBE_MII_100BASE_T_ADVERTISE;
 740                 if (hw->phy.autoneg_advertised & TXGBE_LINK_SPEED_100M_FULL)
 741                         autoneg_reg |= TXGBE_MII_100BASE_T_ADVERTISE;
 742
 743                 hw->phy.write_reg(hw, TXGBE_MII_AUTONEG_ADVERTISE_REG,
 744                                       TXGBE_MD_DEV_AUTO_NEG,
 745                                       autoneg_reg);
 746         }
 747
 748         /* Blocked by MNG FW so don't reset PHY */
 749         if (txgbe_check_reset_blocked(hw))
 750                 return err;
 751
 752         /* Restart PHY auto-negotiation. */
 753         hw->phy.read_reg(hw, TXGBE_MD_AUTO_NEG_CONTROL,
 754                              TXGBE_MD_DEV_AUTO_NEG, &autoneg_reg);
 755
 756         autoneg_reg |= TXGBE_MII_RESTART;
 757
 758         hw->phy.write_reg(hw, TXGBE_MD_AUTO_NEG_CONTROL,
 759                               TXGBE_MD_DEV_AUTO_NEG, autoneg_reg);
 760
 761         return err;
 762 }
 763
 764 /**
 765  *  txgbe_identify_module - Identifies module type
 766  *  @hw: pointer to hardware structure
 767  *
 768  *  Determines HW type and calls appropriate function.
 769  **/
 770 s32 txgbe_identify_module(struct txgbe_hw *hw)
 771 {
 772         s32 err = TXGBE_ERR_SFP_NOT_PRESENT;
 773
 774         DEBUGFUNC("txgbe_identify_module");
 775
 776         switch (hw->phy.media_type) {
 777         case txgbe_media_type_fiber:
 778                 err = txgbe_identify_sfp_module(hw);
 779                 break;
 780
 781         case txgbe_media_type_fiber_qsfp:
 782                 err = txgbe_identify_qsfp_module(hw);
 783                 break;
 784
 785         default:
 786                 hw->phy.sfp_type = txgbe_sfp_type_not_present;
 787                 err = TXGBE_ERR_SFP_NOT_PRESENT;
 788                 break;
 789         }
 790
 791         return err;
 792 }
 793
 794 /**
 795  *  txgbe_identify_sfp_module - Identifies SFP modules
 796  *  @hw: pointer to hardware structure
 797  *
 798  *  Searches for and identifies the SFP module and assigns appropriate PHY type.
 799  **/
 800 s32 txgbe_identify_sfp_module(struct txgbe_hw *hw)
 801 {
 802         s32 err = TXGBE_ERR_PHY_ADDR_INVALID;
 803         u32 vendor_oui = 0;
 804         enum txgbe_sfp_type stored_sfp_type = hw->phy.sfp_type;
 805         u8 identifier = 0;
 806         u8 comp_codes_1g = 0;
 807         u8 comp_codes_10g = 0;
 808         u8 oui_bytes[3] = {0, 0, 0};
 809         u8 cable_tech = 0;
 810         u8 cable_spec = 0;
 811         u16 enforce_sfp = 0;
 812
 813         DEBUGFUNC("txgbe_identify_sfp_module");
 814
 815         if (hw->phy.media_type != txgbe_media_type_fiber) {
 816                 hw->phy.sfp_type = txgbe_sfp_type_not_present;
 817                 return TXGBE_ERR_SFP_NOT_PRESENT;
 818         }
 819
 820         err = hw->phy.read_i2c_eeprom(hw, TXGBE_SFF_IDENTIFIER,
 821                                              &identifier);
 822         if (err != 0) {
 823 ERR_I2C:
 824                 hw->phy.sfp_type = txgbe_sfp_type_not_present;
 825                 if (hw->phy.type != txgbe_phy_nl) {
 826                         hw->phy.id = 0;
 827                         hw->phy.type = txgbe_phy_unknown;
 828                 }
 829                 return TXGBE_ERR_SFP_NOT_PRESENT;
 830         }
 831
 832         if (identifier != TXGBE_SFF_IDENTIFIER_SFP) {
 833                 hw->phy.type = txgbe_phy_sfp_unsupported;
 834                 return TXGBE_ERR_SFP_NOT_SUPPORTED;
 835         }
 836
 837         err = hw->phy.read_i2c_eeprom(hw, TXGBE_SFF_1GBE_COMP_CODES,
 838                                              &comp_codes_1g);
 839         if (err != 0)
 840                 goto ERR_I2C;
 841
 842         err = hw->phy.read_i2c_eeprom(hw, TXGBE_SFF_10GBE_COMP_CODES,
 843                                              &comp_codes_10g);
 844         if (err != 0)
 845                 goto ERR_I2C;
 846
 847         err = hw->phy.read_i2c_eeprom(hw, TXGBE_SFF_CABLE_TECHNOLOGY,
 848                                              &cable_tech);
 849         if (err != 0)
 850                 goto ERR_I2C;
 851
 852          /* ID Module
 853           * =========
 854           * 0   SFP_DA_CU
 855           * 1   SFP_SR
 856           * 2   SFP_LR
 857           * 3   SFP_DA_CORE0 - chip-specific
 858           * 4   SFP_DA_CORE1 - chip-specific
 859           * 5   SFP_SR/LR_CORE0 - chip-specific
 860           * 6   SFP_SR/LR_CORE1 - chip-specific
 861           * 7   SFP_act_lmt_DA_CORE0 - chip-specific
 862           * 8   SFP_act_lmt_DA_CORE1 - chip-specific
 863           * 9   SFP_1g_cu_CORE0 - chip-specific
 864           * 10  SFP_1g_cu_CORE1 - chip-specific
 865           * 11  SFP_1g_sx_CORE0 - chip-specific
 866           * 12  SFP_1g_sx_CORE1 - chip-specific
 867           */
 868         if (cable_tech & TXGBE_SFF_CABLE_DA_PASSIVE) {
 869                 if (hw->bus.lan_id == 0)
 870                         hw->phy.sfp_type = txgbe_sfp_type_da_cu_core0;
 871                 else
 872                         hw->phy.sfp_type = txgbe_sfp_type_da_cu_core1;
 873         } else if (cable_tech & TXGBE_SFF_CABLE_DA_ACTIVE) {
 874                 err = hw->phy.read_i2c_eeprom(hw,
 875                         TXGBE_SFF_CABLE_SPEC_COMP, &cable_spec);
 876                 if (err != 0)
 877                         goto ERR_I2C;
 878                 if (cable_spec & TXGBE_SFF_DA_SPEC_ACTIVE_LIMITING) {
 879                         hw->phy.sfp_type = (hw->bus.lan_id == 0
 880                                 ? txgbe_sfp_type_da_act_lmt_core0
 881                                 : txgbe_sfp_type_da_act_lmt_core1);
 882                 } else {
 883                         hw->phy.sfp_type = txgbe_sfp_type_unknown;
 884                 }
 885         } else if (comp_codes_10g &
 886                    (TXGBE_SFF_10GBASESR_CAPABLE |
 887                     TXGBE_SFF_10GBASELR_CAPABLE)) {
 888                 hw->phy.sfp_type = (hw->bus.lan_id == 0
 889                                 ? txgbe_sfp_type_srlr_core0
 890                                 : txgbe_sfp_type_srlr_core1);
 891         } else if (comp_codes_1g & TXGBE_SFF_1GBASET_CAPABLE) {
 892                 hw->phy.sfp_type = (hw->bus.lan_id == 0
 893                                 ? txgbe_sfp_type_1g_cu_core0
 894                                 : txgbe_sfp_type_1g_cu_core1);
 895         } else if (comp_codes_1g & TXGBE_SFF_1GBASESX_CAPABLE) {
 896                 hw->phy.sfp_type = (hw->bus.lan_id == 0
 897                                 ? txgbe_sfp_type_1g_sx_core0
 898                                 : txgbe_sfp_type_1g_sx_core1);
 899         } else if (comp_codes_1g & TXGBE_SFF_1GBASELX_CAPABLE) {
 900                 hw->phy.sfp_type = (hw->bus.lan_id == 0
 901                                 ? txgbe_sfp_type_1g_lx_core0
 902                                 : txgbe_sfp_type_1g_lx_core1);
 903         } else {
 904                 hw->phy.sfp_type = txgbe_sfp_type_unknown;
 905         }
 906
 907         if (hw->phy.sfp_type != stored_sfp_type)
 908                 hw->phy.sfp_setup_needed = true;
 909
 910         /* Determine if the SFP+ PHY is dual speed or not. */
 911         hw->phy.multispeed_fiber = false;
 912         if (((comp_codes_1g & TXGBE_SFF_1GBASESX_CAPABLE) &&
 913              (comp_codes_10g & TXGBE_SFF_10GBASESR_CAPABLE)) ||
 914             ((comp_codes_1g & TXGBE_SFF_1GBASELX_CAPABLE) &&
 915              (comp_codes_10g & TXGBE_SFF_10GBASELR_CAPABLE)))
 916                 hw->phy.multispeed_fiber = true;
 917
 918         /* Determine PHY vendor */
 919         if (hw->phy.type != txgbe_phy_nl) {
 920                 hw->phy.id = identifier;
 921                 err = hw->phy.read_i2c_eeprom(hw,
 922                         TXGBE_SFF_VENDOR_OUI_BYTE0, &oui_bytes[0]);
 923                 if (err != 0)
 924                         goto ERR_I2C;
 925
 926                 err = hw->phy.read_i2c_eeprom(hw,
 927                         TXGBE_SFF_VENDOR_OUI_BYTE1, &oui_bytes[1]);
 928                 if (err != 0)
 929                         goto ERR_I2C;
 930
 931                 err = hw->phy.read_i2c_eeprom(hw,
 932                         TXGBE_SFF_VENDOR_OUI_BYTE2, &oui_bytes[2]);
 933                 if (err != 0)
 934                         goto ERR_I2C;
 935
 936                 vendor_oui = ((u32)oui_bytes[0] << 24) |
 937                              ((u32)oui_bytes[1] << 16) |
 938                              ((u32)oui_bytes[2] << 8);
 939                 switch (vendor_oui) {
 940                 case TXGBE_SFF_VENDOR_OUI_TYCO:
 941                         if (cable_tech & TXGBE_SFF_CABLE_DA_PASSIVE)
 942                                 hw->phy.type = txgbe_phy_sfp_tyco_passive;
 943                         break;
 944                 case TXGBE_SFF_VENDOR_OUI_FTL:
 945                         if (cable_tech & TXGBE_SFF_CABLE_DA_ACTIVE)
 946                                 hw->phy.type = txgbe_phy_sfp_ftl_active;
 947                         else
 948                                 hw->phy.type = txgbe_phy_sfp_ftl;
 949                         break;
 950                 case TXGBE_SFF_VENDOR_OUI_AVAGO:
 951                         hw->phy.type = txgbe_phy_sfp_avago;
 952                         break;
 953                 case TXGBE_SFF_VENDOR_OUI_INTEL:
 954                         hw->phy.type = txgbe_phy_sfp_intel;
 955                         break;
 956                 default:
 957                         if (cable_tech & TXGBE_SFF_CABLE_DA_PASSIVE)
 958                                 hw->phy.type = txgbe_phy_sfp_unknown_passive;
 959                         else if (cable_tech & TXGBE_SFF_CABLE_DA_ACTIVE)
 960                                 hw->phy.type = txgbe_phy_sfp_unknown_active;
 961                         else
 962                                 hw->phy.type = txgbe_phy_sfp_unknown;
 963                         break;
 964                 }
 965         }
 966
 967         /* Allow any DA cable vendor */
 968         if (cable_tech & (TXGBE_SFF_CABLE_DA_PASSIVE |
 969                           TXGBE_SFF_CABLE_DA_ACTIVE)) {
 970                 return 0;
 971         }
 972
 973         /* Verify supported 1G SFP modules */
 974         if (comp_codes_10g == 0 &&
 975             !(hw->phy.sfp_type == txgbe_sfp_type_1g_cu_core1 ||
 976               hw->phy.sfp_type == txgbe_sfp_type_1g_cu_core0 ||
 977               hw->phy.sfp_type == txgbe_sfp_type_1g_lx_core0 ||
 978               hw->phy.sfp_type == txgbe_sfp_type_1g_lx_core1 ||
 979               hw->phy.sfp_type == txgbe_sfp_type_1g_sx_core0 ||
 980               hw->phy.sfp_type == txgbe_sfp_type_1g_sx_core1)) {
 981                 hw->phy.type = txgbe_phy_sfp_unsupported;
 982                 return TXGBE_ERR_SFP_NOT_SUPPORTED;
 983         }
 984
 985         hw->mac.get_device_caps(hw, &enforce_sfp);
 986         if (!(enforce_sfp & TXGBE_DEVICE_CAPS_ALLOW_ANY_SFP) &&
 987             !hw->allow_unsupported_sfp &&
 988             !(hw->phy.sfp_type == txgbe_sfp_type_1g_cu_core0 ||
 989               hw->phy.sfp_type == txgbe_sfp_type_1g_cu_core1 ||
 990               hw->phy.sfp_type == txgbe_sfp_type_1g_lx_core0 ||
 991               hw->phy.sfp_type == txgbe_sfp_type_1g_lx_core1 ||
 992               hw->phy.sfp_type == txgbe_sfp_type_1g_sx_core0 ||
 993               hw->phy.sfp_type == txgbe_sfp_type_1g_sx_core1)) {
 994                 DEBUGOUT("SFP+ module not supported\n");
 995                 hw->phy.type = txgbe_phy_sfp_unsupported;
 996                 return TXGBE_ERR_SFP_NOT_SUPPORTED;
 997         }
 998
 999         return err;
1000 }
1001
1002 /**
1003  *  txgbe_identify_qsfp_module - Identifies QSFP modules
1004  *  @hw: pointer to hardware structure
1005  *
1006  *  Searches for and identifies the QSFP module and assigns appropriate PHY type
1007  **/
1008 s32 txgbe_identify_qsfp_module(struct txgbe_hw *hw)
1009 {
1010         s32 err = TXGBE_ERR_PHY_ADDR_INVALID;
1011         u32 vendor_oui = 0;
1012         enum txgbe_sfp_type stored_sfp_type = hw->phy.sfp_type;
1013         u8 identifier = 0;
1014         u8 comp_codes_1g = 0;
1015         u8 comp_codes_10g = 0;
1016         u8 oui_bytes[3] = {0, 0, 0};
1017         u16 enforce_sfp = 0;
1018         u8 connector = 0;
1019         u8 cable_length = 0;
1020         u8 device_tech = 0;
1021         bool active_cable = false;
1022
1023         DEBUGFUNC("txgbe_identify_qsfp_module");
1024
1025         if (hw->phy.media_type != txgbe_media_type_fiber_qsfp) {
1026                 hw->phy.sfp_type = txgbe_sfp_type_not_present;
1027                 err = TXGBE_ERR_SFP_NOT_PRESENT;
1028                 goto out;
1029         }
1030
1031         err = hw->phy.read_i2c_eeprom(hw, TXGBE_SFF_IDENTIFIER,
1032                                              &identifier);
1033 ERR_I2C:
1034         if (err != 0) {
1035                 hw->phy.sfp_type = txgbe_sfp_type_not_present;
1036                 hw->phy.id = 0;
1037                 hw->phy.type = txgbe_phy_unknown;
1038                 return TXGBE_ERR_SFP_NOT_PRESENT;
1039         }
1040         if (identifier != TXGBE_SFF_IDENTIFIER_QSFP_PLUS) {
1041                 hw->phy.type = txgbe_phy_sfp_unsupported;
1042                 err = TXGBE_ERR_SFP_NOT_SUPPORTED;
1043                 goto out;
1044         }
1045
1046         hw->phy.id = identifier;
1047
1048         err = hw->phy.read_i2c_eeprom(hw, TXGBE_SFF_QSFP_10GBE_COMP,
1049                                              &comp_codes_10g);
1050
1051         if (err != 0)
1052                 goto ERR_I2C;
1053
1054         err = hw->phy.read_i2c_eeprom(hw, TXGBE_SFF_QSFP_1GBE_COMP,
1055                                              &comp_codes_1g);
1056
1057         if (err != 0)
1058                 goto ERR_I2C;
1059
1060         if (comp_codes_10g & TXGBE_SFF_QSFP_DA_PASSIVE_CABLE) {
1061                 hw->phy.type = txgbe_phy_qsfp_unknown_passive;
1062                 if (hw->bus.lan_id == 0)
1063                         hw->phy.sfp_type = txgbe_sfp_type_da_cu_core0;
1064                 else
1065                         hw->phy.sfp_type = txgbe_sfp_type_da_cu_core1;
1066         } else if (comp_codes_10g & (TXGBE_SFF_10GBASESR_CAPABLE |
1067                                      TXGBE_SFF_10GBASELR_CAPABLE)) {
1068                 if (hw->bus.lan_id == 0)
1069                         hw->phy.sfp_type = txgbe_sfp_type_srlr_core0;
1070                 else
1071                         hw->phy.sfp_type = txgbe_sfp_type_srlr_core1;
1072         } else {
1073                 if (comp_codes_10g & TXGBE_SFF_QSFP_DA_ACTIVE_CABLE)
1074                         active_cable = true;
1075
1076                 if (!active_cable) {
1077                         hw->phy.read_i2c_eeprom(hw,
1078                                         TXGBE_SFF_QSFP_CONNECTOR,
1079                                         &connector);
1080
1081                         hw->phy.read_i2c_eeprom(hw,
1082                                         TXGBE_SFF_QSFP_CABLE_LENGTH,
1083                                         &cable_length);
1084
1085                         hw->phy.read_i2c_eeprom(hw,
1086                                         TXGBE_SFF_QSFP_DEVICE_TECH,
1087                                         &device_tech);
1088
1089                         if (connector ==
1090                                      TXGBE_SFF_QSFP_CONNECTOR_NOT_SEPARABLE &&
1091                             cable_length > 0 &&
1092                             ((device_tech >> 4) ==
1093                                      TXGBE_SFF_QSFP_TRANSMITTER_850NM_VCSEL))
1094                                 active_cable = true;
1095                 }
1096
1097                 if (active_cable) {
1098                         hw->phy.type = txgbe_phy_qsfp_unknown_active;
1099                         if (hw->bus.lan_id == 0)
1100                                 hw->phy.sfp_type =
1101                                         txgbe_sfp_type_da_act_lmt_core0;
1102                         else
1103                                 hw->phy.sfp_type =
1104                                         txgbe_sfp_type_da_act_lmt_core1;
1105                 } else {
1106                         /* unsupported module type */
1107                         hw->phy.type = txgbe_phy_sfp_unsupported;
1108                         err = TXGBE_ERR_SFP_NOT_SUPPORTED;
1109                         goto out;
1110                 }
1111         }
1112
1113         if (hw->phy.sfp_type != stored_sfp_type)
1114                 hw->phy.sfp_setup_needed = true;
1115
1116         /* Determine if the QSFP+ PHY is dual speed or not. */
1117         hw->phy.multispeed_fiber = false;
1118         if (((comp_codes_1g & TXGBE_SFF_1GBASESX_CAPABLE) &&
1119            (comp_codes_10g & TXGBE_SFF_10GBASESR_CAPABLE)) ||
1120            ((comp_codes_1g & TXGBE_SFF_1GBASELX_CAPABLE) &&
1121            (comp_codes_10g & TXGBE_SFF_10GBASELR_CAPABLE)))
1122                 hw->phy.multispeed_fiber = true;
1123
1124         /* Determine PHY vendor for optical modules */
1125         if (comp_codes_10g & (TXGBE_SFF_10GBASESR_CAPABLE |
1126                               TXGBE_SFF_10GBASELR_CAPABLE))  {
1127                 err = hw->phy.read_i2c_eeprom(hw,
1128                                             TXGBE_SFF_QSFP_VENDOR_OUI_BYTE0,
1129                                             &oui_bytes[0]);
1130
1131                 if (err != 0)
1132                         goto ERR_I2C;
1133
1134                 err = hw->phy.read_i2c_eeprom(hw,
1135                                             TXGBE_SFF_QSFP_VENDOR_OUI_BYTE1,
1136                                             &oui_bytes[1]);
1137
1138                 if (err != 0)
1139                         goto ERR_I2C;
1140
1141                 err = hw->phy.read_i2c_eeprom(hw,
1142                                             TXGBE_SFF_QSFP_VENDOR_OUI_BYTE2,
1143                                             &oui_bytes[2]);
1144
1145                 if (err != 0)
1146                         goto ERR_I2C;
1147
1148                 vendor_oui =
1149                   ((oui_bytes[0] << 24) |
1150                    (oui_bytes[1] << 16) |
1151                    (oui_bytes[2] << 8));
1152
1153                 if (vendor_oui == TXGBE_SFF_VENDOR_OUI_INTEL)
1154                         hw->phy.type = txgbe_phy_qsfp_intel;
1155                 else
1156                         hw->phy.type = txgbe_phy_qsfp_unknown;
1157
1158                 hw->mac.get_device_caps(hw, &enforce_sfp);
1159                 if (!(enforce_sfp & TXGBE_DEVICE_CAPS_ALLOW_ANY_SFP)) {
1160                         /* Make sure we're a supported PHY type */
1161                         if (hw->phy.type == txgbe_phy_qsfp_intel) {
1162                                 err = 0;
1163                         } else {
1164                                 if (hw->allow_unsupported_sfp) {
1165                                         DEBUGOUT("WARNING: Wangxun (R) Network Connections are quality tested using Wangxun (R) Ethernet Optics. "
1166                                                 "Using untested modules is not supported and may cause unstable operation or damage to the module or the adapter. "
1167                                                 "Wangxun Corporation is not responsible for any harm caused by using untested modules.\n");
1168                                         err = 0;
1169                                 } else {
1170                                         DEBUGOUT("QSFP module not supported\n");
1171                                         hw->phy.type =
1172                                                 txgbe_phy_sfp_unsupported;
1173                                         err = TXGBE_ERR_SFP_NOT_SUPPORTED;
1174                                 }
1175                         }
1176                 } else {
1177                         err = 0;
1178                 }
1179         }
1180
1181 out:
1182         return err;
1183 }
1184
1185 /**
1186  *  txgbe_read_i2c_eeprom - Reads 8 bit EEPROM word over I2C interface
1187  *  @hw: pointer to hardware structure
1188  *  @byte_offset: EEPROM byte offset to read
1189  *  @eeprom_data: value read
1190  *
1191  *  Performs byte read operation to SFP module's EEPROM over I2C interface.
1192  **/
1193 s32 txgbe_read_i2c_eeprom(struct txgbe_hw *hw, u8 byte_offset,
1194                                   u8 *eeprom_data)
1195 {
1196         DEBUGFUNC("txgbe_read_i2c_eeprom");
1197
1198         return hw->phy.read_i2c_byte(hw, byte_offset,
1199                                          TXGBE_I2C_EEPROM_DEV_ADDR,
1200                                          eeprom_data);
1201 }
1202
1203 /**
1204  *  txgbe_read_i2c_sff8472 - Reads 8 bit word over I2C interface
1205  *  @hw: pointer to hardware structure
1206  *  @byte_offset: byte offset at address 0xA2
1207  *  @sff8472_data: value read
1208  *
1209  *  Performs byte read operation to SFP module's SFF-8472 data over I2C
1210  **/
1211 s32 txgbe_read_i2c_sff8472(struct txgbe_hw *hw, u8 byte_offset,
1212                                           u8 *sff8472_data)
1213 {
1214         return hw->phy.read_i2c_byte(hw, byte_offset,
1215                                          TXGBE_I2C_EEPROM_DEV_ADDR2,
1216                                          sff8472_data);
1217 }
1218
1219 /**
1220  *  txgbe_write_i2c_eeprom - Writes 8 bit EEPROM word over I2C interface
1221  *  @hw: pointer to hardware structure
1222  *  @byte_offset: EEPROM byte offset to write
1223  *  @eeprom_data: value to write
1224  *
1225  *  Performs byte write operation to SFP module's EEPROM over I2C interface.
1226  **/
1227 s32 txgbe_write_i2c_eeprom(struct txgbe_hw *hw, u8 byte_offset,
1228                                    u8 eeprom_data)
1229 {
1230         DEBUGFUNC("txgbe_write_i2c_eeprom");
1231
1232         return hw->phy.write_i2c_byte(hw, byte_offset,
1233                                           TXGBE_I2C_EEPROM_DEV_ADDR,
1234                                           eeprom_data);
1235 }
1236
1237 /**
1238  *  txgbe_read_i2c_byte_unlocked - Reads 8 bit word over I2C
1239  *  @hw: pointer to hardware structure
1240  *  @byte_offset: byte offset to read
1241  *  @dev_addr: address to read from
1242  *  @data: value read
1243  *
1244  *  Performs byte read operation to SFP module's EEPROM over I2C interface at
1245  *  a specified device address.
1246  **/
1247 s32 txgbe_read_i2c_byte_unlocked(struct txgbe_hw *hw, u8 byte_offset,
1248                                            u8 dev_addr, u8 *data)
1249 {
1250         UNREFERENCED_PARAMETER(dev_addr);
1251
1252         DEBUGFUNC("txgbe_read_i2c_byte");
1253
1254         txgbe_i2c_start(hw);
1255
1256         /* wait tx empty */
1257         if (!po32m(hw, TXGBE_I2CICR, TXGBE_I2CICR_TXEMPTY,
1258                 TXGBE_I2CICR_TXEMPTY, NULL, 100, 100)) {
1259                 return -TERR_TIMEOUT;
1260         }
1261
1262         /* read data */
1263         wr32(hw, TXGBE_I2CDATA,
1264                         byte_offset | TXGBE_I2CDATA_STOP);
1265         wr32(hw, TXGBE_I2CDATA, TXGBE_I2CDATA_READ);
1266
1267         /* wait for read complete */
1268         if (!po32m(hw, TXGBE_I2CICR, TXGBE_I2CICR_RXFULL,
1269                 TXGBE_I2CICR_RXFULL, NULL, 100, 100)) {
1270                 return -TERR_TIMEOUT;
1271         }
1272
1273         txgbe_i2c_stop(hw);
1274
1275         *data = 0xFF & rd32(hw, TXGBE_I2CDATA);
1276
1277         return 0;
1278 }
1279
1280 /**
1281  *  txgbe_read_i2c_byte - Reads 8 bit word over I2C
1282  *  @hw: pointer to hardware structure
1283  *  @byte_offset: byte offset to read
1284  *  @dev_addr: address to read from
1285  *  @data: value read
1286  *
1287  *  Performs byte read operation to SFP module's EEPROM over I2C interface at
1288  *  a specified device address.
1289  **/
1290 s32 txgbe_read_i2c_byte(struct txgbe_hw *hw, u8 byte_offset,
1291                                 u8 dev_addr, u8 *data)
1292 {
1293         u32 swfw_mask = hw->phy.phy_semaphore_mask;
1294         int err = 0;
1295
1296         if (hw->mac.acquire_swfw_sync(hw, swfw_mask))
1297                 return TXGBE_ERR_SWFW_SYNC;
1298         err = txgbe_read_i2c_byte_unlocked(hw, byte_offset, dev_addr, data);
1299         hw->mac.release_swfw_sync(hw, swfw_mask);
1300         return err;
1301 }
1302
1303 /**
1304  *  txgbe_write_i2c_byte_unlocked - Writes 8 bit word over I2C
1305  *  @hw: pointer to hardware structure
1306  *  @byte_offset: byte offset to write
1307  *  @dev_addr: address to write to
1308  *  @data: value to write
1309  *
1310  *  Performs byte write operation to SFP module's EEPROM over I2C interface at
1311  *  a specified device address.
1312  **/
1313 s32 txgbe_write_i2c_byte_unlocked(struct txgbe_hw *hw, u8 byte_offset,
1314                                             u8 dev_addr, u8 data)
1315 {
1316         UNREFERENCED_PARAMETER(dev_addr);
1317
1318         DEBUGFUNC("txgbe_write_i2c_byte");
1319
1320         txgbe_i2c_start(hw);
1321
1322         /* wait tx empty */
1323         if (!po32m(hw, TXGBE_I2CICR, TXGBE_I2CICR_TXEMPTY,
1324                 TXGBE_I2CICR_TXEMPTY, NULL, 100, 100)) {
1325                 return -TERR_TIMEOUT;
1326         }
1327
1328         wr32(hw, TXGBE_I2CDATA, byte_offset | TXGBE_I2CDATA_STOP);
1329         wr32(hw, TXGBE_I2CDATA, data | TXGBE_I2CDATA_WRITE);
1330
1331         /* wait for write complete */
1332         if (!po32m(hw, TXGBE_I2CICR, TXGBE_I2CICR_RXFULL,
1333                 TXGBE_I2CICR_RXFULL, NULL, 100, 100)) {
1334                 return -TERR_TIMEOUT;
1335         }
1336         txgbe_i2c_stop(hw);
1337
1338         return 0;
1339 }
1340
1341 /**
1342  *  txgbe_write_i2c_byte - Writes 8 bit word over I2C
1343  *  @hw: pointer to hardware structure
1344  *  @byte_offset: byte offset to write
1345  *  @dev_addr: address to write to
1346  *  @data: value to write
1347  *
1348  *  Performs byte write operation to SFP module's EEPROM over I2C interface at
1349  *  a specified device address.
1350  **/
1351 s32 txgbe_write_i2c_byte(struct txgbe_hw *hw, u8 byte_offset,
1352                                  u8 dev_addr, u8 data)
1353 {
1354         u32 swfw_mask = hw->phy.phy_semaphore_mask;
1355         int err = 0;
1356
1357         if (hw->mac.acquire_swfw_sync(hw, swfw_mask))
1358                 return TXGBE_ERR_SWFW_SYNC;
1359         err = txgbe_write_i2c_byte_unlocked(hw, byte_offset, dev_addr, data);
1360         hw->mac.release_swfw_sync(hw, swfw_mask);
1361
1362         return err;
1363 }
1364
1365 /**
1366  *  txgbe_i2c_start - Sets I2C start condition
1367  *  @hw: pointer to hardware structure
1368  *
1369  *  Sets I2C start condition (High -> Low on SDA while SCL is High)
1370  **/
1371 static void txgbe_i2c_start(struct txgbe_hw *hw)
1372 {
1373         DEBUGFUNC("txgbe_i2c_start");
1374
1375         wr32(hw, TXGBE_I2CENA, 0);
1376
1377         wr32(hw, TXGBE_I2CCON,
1378                 (TXGBE_I2CCON_MENA |
1379                 TXGBE_I2CCON_SPEED(1) |
1380                 TXGBE_I2CCON_RESTART |
1381                 TXGBE_I2CCON_SDIA));
1382         wr32(hw, TXGBE_I2CTAR, TXGBE_I2C_SLAVEADDR);
1383         wr32(hw, TXGBE_I2CSSSCLHCNT, 600);
1384         wr32(hw, TXGBE_I2CSSSCLLCNT, 600);
1385         wr32(hw, TXGBE_I2CRXTL, 0); /* 1byte for rx full signal */
1386         wr32(hw, TXGBE_I2CTXTL, 4);
1387         wr32(hw, TXGBE_I2CSCLTMOUT, 0xFFFFFF);
1388         wr32(hw, TXGBE_I2CSDATMOUT, 0xFFFFFF);
1389
1390         wr32(hw, TXGBE_I2CICM, 0);
1391         wr32(hw, TXGBE_I2CENA, 1);
1392 }
1393
1394 /**
1395  *  txgbe_i2c_stop - Sets I2C stop condition
1396  *  @hw: pointer to hardware structure
1397  *
1398  *  Sets I2C stop condition (Low -> High on SDA while SCL is High)
1399  **/
1400 static void txgbe_i2c_stop(struct txgbe_hw *hw)
1401 {
1402         DEBUGFUNC("txgbe_i2c_stop");
1403
1404         /* wait for completion */
1405         if (!po32m(hw, TXGBE_I2CSTAT, TXGBE_I2CSTAT_MST,
1406                 0, NULL, 100, 100)) {
1407                 DEBUGFUNC("i2c stop timeout.");
1408         }
1409
1410         wr32(hw, TXGBE_I2CENA, 0);
1411 }
1412
1413 static void
1414 txgbe_set_sgmii_an37_ability(struct txgbe_hw *hw)
1415 {
1416         u32 value;
1417
1418         wr32_epcs(hw, VR_XS_OR_PCS_MMD_DIGI_CTL1, 0x3002);
1419         wr32_epcs(hw, SR_MII_MMD_AN_CTL, 0x0105);
1420         wr32_epcs(hw, SR_MII_MMD_DIGI_CTL, 0x0200);
1421         value = rd32_epcs(hw, SR_MII_MMD_CTL);
1422         value = (value & ~0x1200) | (0x1 << 12) | (0x1 << 9);
1423         wr32_epcs(hw, SR_MII_MMD_CTL, value);
1424 }
1425
1426 static s32
1427 txgbe_set_link_to_kr(struct txgbe_hw *hw, bool autoneg)
1428 {
1429         u32 i;
1430         u16 value;
1431         s32 err = 0;
1432
1433         /* 1. Wait xpcs power-up good */
1434         for (i = 0; i < 100; i++) {
1435                 if ((rd32_epcs(hw, VR_XS_OR_PCS_MMD_DIGI_STATUS) &
1436                         VR_XS_OR_PCS_MMD_DIGI_STATUS_PSEQ_MASK) ==
1437                         VR_XS_OR_PCS_MMD_DIGI_STATUS_PSEQ_POWER_GOOD)
1438                         break;
1439                 msec_delay(10);
1440         }
1441         if (i == 100) {
1442                 err = TXGBE_ERR_XPCS_POWER_UP_FAILED;
1443                 goto out;
1444         }
1445         BP_LOG("It is set to kr.\n");
1446
1447         wr32_epcs(hw, VR_AN_INTR_MSK, 0x7);
1448         wr32_epcs(hw, TXGBE_PHY_TX_POWER_ST_CTL, 0x00FC);
1449         wr32_epcs(hw, TXGBE_PHY_RX_POWER_ST_CTL, 0x00FC);
1450
1451         if (!autoneg) {
1452                 /* 2. Disable xpcs AN-73 */
1453                 wr32_epcs(hw, SR_AN_CTRL,
1454                         SR_AN_CTRL_AN_EN | SR_AN_CTRL_EXT_NP);
1455
1456                 wr32_epcs(hw, VR_AN_KR_MODE_CL, VR_AN_KR_MODE_CL_PDET);
1457
1458                 if (!(hw->devarg.auto_neg == 1)) {
1459                         wr32_epcs(hw, SR_AN_CTRL, 0);
1460                         wr32_epcs(hw, VR_AN_KR_MODE_CL, 0);
1461                 }
1462                 if (hw->devarg.present  == 1) {
1463                         value = rd32_epcs(hw, TXGBE_PHY_TX_EQ_CTL1);
1464                         value |= TXGBE_PHY_TX_EQ_CTL1_DEF;
1465                         wr32_epcs(hw, TXGBE_PHY_TX_EQ_CTL1, value);
1466                 }
1467                 if (hw->devarg.poll == 1) {
1468                         wr32_epcs(hw, VR_PMA_KRTR_TIMER_CTRL0,
1469                                 VR_PMA_KRTR_TIMER_MAX_WAIT);
1470                         wr32_epcs(hw, VR_PMA_KRTR_TIMER_CTRL2, 0xA697);
1471                 }
1472
1473                 /* 3. Set VR_XS_PMA_Gen5_12G_MPLLA_CTRL3 Register
1474                  * Bit[10:0](MPLLA_BANDWIDTH) = 11'd123 (default: 11'd16)
1475                  */
1476                 wr32_epcs(hw, TXGBE_PHY_MPLLA_CTL3,
1477                         TXGBE_PHY_MPLLA_CTL3_MULTIPLIER_BW_10GBASER_KR);
1478
1479                 /* 4. Set VR_XS_PMA_Gen5_12G_MISC_CTRL0 Register
1480                  * Bit[12:8](RX_VREF_CTRL) = 5'hF (default: 5'h11)
1481                  */
1482                 wr32_epcs(hw, TXGBE_PHY_MISC_CTL0, 0xCF00);
1483
1484                 /* 5. Set VR_XS_PMA_Gen5_12G_RX_EQ_CTRL0 Register
1485                  * Bit[15:8](VGA1/2_GAIN_0) = 8'h77
1486                  * Bit[7:5](CTLE_POLE_0) = 3'h2
1487                  * Bit[4:0](CTLE_BOOST_0) = 4'hA
1488                  */
1489                 wr32_epcs(hw, TXGBE_PHY_RX_EQ_CTL0, 0x774A);
1490
1491                 /* 6. Set VR_MII_Gen5_12G_RX_GENCTRL3 Register
1492                  * Bit[2:0](LOS_TRSHLD_0) = 3'h4 (default: 3)
1493                  */
1494                 wr32_epcs(hw, TXGBE_PHY_RX_GEN_CTL3, 0x0004);
1495
1496                 /* 7. Initialize the mode by setting VR XS or PCS MMD Digital
1497                  * Control1 Register Bit[15](VR_RST)
1498                  */
1499                 wr32_epcs(hw, VR_XS_OR_PCS_MMD_DIGI_CTL1, 0xA000);
1500
1501                 /* Wait phy initialization done */
1502                 for (i = 0; i < 100; i++) {
1503                         if ((rd32_epcs(hw,
1504                                 VR_XS_OR_PCS_MMD_DIGI_CTL1) &
1505                                 VR_XS_OR_PCS_MMD_DIGI_CTL1_VR_RST) == 0)
1506                                 break;
1507                         msleep(100);
1508                 }
1509                 if (i == 100) {
1510                         err = TXGBE_ERR_PHY_INIT_NOT_DONE;
1511                         goto out;
1512                 }
1513         } else {
1514                 wr32_epcs(hw, VR_AN_KR_MODE_CL, 0x1);
1515         }
1516 out:
1517         return err;
1518 }
1519
1520 static s32
1521 txgbe_set_link_to_kx4(struct txgbe_hw *hw, bool autoneg)
1522 {
1523         u32 i;
1524         s32 err = 0;
1525         u32 value;
1526
1527         /* Check link status, if already set, skip setting it again */
1528         if (hw->link_status == TXGBE_LINK_STATUS_KX4)
1529                 goto out;
1530
1531         BP_LOG("It is set to kx4.\n");
1532         wr32_epcs(hw, TXGBE_PHY_TX_POWER_ST_CTL, 0);
1533         wr32_epcs(hw, TXGBE_PHY_RX_POWER_ST_CTL, 0);
1534
1535         /* 1. Wait xpcs power-up good */
1536         for (i = 0; i < 100; i++) {
1537                 if ((rd32_epcs(hw, VR_XS_OR_PCS_MMD_DIGI_STATUS) &
1538                         VR_XS_OR_PCS_MMD_DIGI_STATUS_PSEQ_MASK) ==
1539                         VR_XS_OR_PCS_MMD_DIGI_STATUS_PSEQ_POWER_GOOD)
1540                         break;
1541                 msec_delay(10);
1542         }
1543         if (i == 100) {
1544                 err = TXGBE_ERR_XPCS_POWER_UP_FAILED;
1545                 goto out;
1546         }
1547
1548         wr32m(hw, TXGBE_MACTXCFG, TXGBE_MACTXCFG_TXE,
1549                         ~TXGBE_MACTXCFG_TXE);
1550
1551         /* 2. Disable xpcs AN-73 */
1552         if (!autoneg)
1553                 wr32_epcs(hw, SR_AN_CTRL, 0x0);
1554         else
1555                 wr32_epcs(hw, SR_AN_CTRL, 0x3000);
1556
1557         /* Disable PHY MPLLA for eth mode change(after ECO) */
1558         wr32_ephy(hw, 0x4, 0x250A);
1559         txgbe_flush(hw);
1560         msec_delay(1);
1561
1562         /* Set the eth change_mode bit first in mis_rst register
1563          * for corresponding LAN port
1564          */
1565         wr32(hw, TXGBE_RST, TXGBE_RST_ETH(hw->bus.lan_id));
1566
1567         /* Set SR PCS Control2 Register Bits[1:0] = 2'b01
1568          * PCS_TYPE_SEL: non KR
1569          */
1570         wr32_epcs(hw, SR_XS_PCS_CTRL2,
1571                         SR_PCS_CTRL2_TYPE_SEL_X);
1572
1573         /* Set SR PMA MMD Control1 Register Bit[13] = 1'b1
1574          * SS13: 10G speed
1575          */
1576         wr32_epcs(hw, SR_PMA_CTRL1,
1577                         SR_PMA_CTRL1_SS13_KX4);
1578
1579         value = (0xf5f0 & ~0x7F0) |  (0x5 << 8) | (0x7 << 5) | 0xF0;
1580         wr32_epcs(hw, TXGBE_PHY_TX_GENCTRL1, value);
1581
1582         if ((hw->subsystem_device_id & 0xFF) == TXGBE_DEV_ID_MAC_XAUI)
1583                 wr32_epcs(hw, TXGBE_PHY_MISC_CTL0, 0xCF00);
1584         else
1585                 wr32_epcs(hw, TXGBE_PHY_MISC_CTL0, 0x4F00);
1586
1587         for (i = 0; i < 4; i++) {
1588                 if (i == 0)
1589                         value = (0x45 & ~0xFFFF) | (0x7 << 12) |
1590                                 (0x7 << 8) | 0x6;
1591                 else
1592                         value = (0xff06 & ~0xFFFF) | (0x7 << 12) |
1593                                 (0x7 << 8) | 0x6;
1594                 wr32_epcs(hw, TXGBE_PHY_RX_EQ_CTL0 + i, value);
1595         }
1596
1597         value = 0x0 & ~0x7777;
1598         wr32_epcs(hw, TXGBE_PHY_RX_EQ_ATT_LVL0, value);
1599
1600         wr32_epcs(hw, TXGBE_PHY_DFE_TAP_CTL0, 0x0);
1601
1602         value = (0x6db & ~0xFFF) | (0x1 << 9) | (0x1 << 6) | (0x1 << 3) | 0x1;
1603         wr32_epcs(hw, TXGBE_PHY_RX_GEN_CTL3, value);
1604
1605         /* Set VR XS, PMA, or MII Gen5 12G PHY MPLLA
1606          * Control 0 Register Bit[7:0] = 8'd40  //MPLLA_MULTIPLIER
1607          */
1608         wr32_epcs(hw, TXGBE_PHY_MPLLA_CTL0,
1609                         TXGBE_PHY_MPLLA_CTL0_MULTIPLIER_OTHER);
1610
1611         /* Set VR XS, PMA or MII Gen5 12G PHY MPLLA
1612          * Control 3 Register Bit[10:0] = 11'd86  //MPLLA_BANDWIDTH
1613          */
1614         wr32_epcs(hw, TXGBE_PHY_MPLLA_CTL3,
1615                         TXGBE_PHY_MPLLA_CTL3_MULTIPLIER_BW_OTHER);
1616
1617         /* Set VR XS, PMA, or MII Gen5 12G PHY VCO
1618          * Calibration Load 0 Register  Bit[12:0] = 13'd1360  //VCO_LD_VAL_0
1619          */
1620         wr32_epcs(hw, TXGBE_PHY_VCO_CAL_LD0,
1621                         TXGBE_PHY_VCO_CAL_LD0_OTHER);
1622
1623         /* Set VR XS, PMA, or MII Gen5 12G PHY VCO
1624          * Calibration Load 1 Register  Bit[12:0] = 13'd1360  //VCO_LD_VAL_1
1625          */
1626         wr32_epcs(hw, TXGBE_PHY_VCO_CAL_LD1,
1627                         TXGBE_PHY_VCO_CAL_LD0_OTHER);
1628
1629         /* Set VR XS, PMA, or MII Gen5 12G PHY VCO
1630          * Calibration Load 2 Register  Bit[12:0] = 13'd1360  //VCO_LD_VAL_2
1631          */
1632         wr32_epcs(hw, TXGBE_PHY_VCO_CAL_LD2,
1633                         TXGBE_PHY_VCO_CAL_LD0_OTHER);
1634         /* Set VR XS, PMA, or MII Gen5 12G PHY VCO
1635          * Calibration Load 3 Register  Bit[12:0] = 13'd1360  //VCO_LD_VAL_3
1636          */
1637         wr32_epcs(hw, TXGBE_PHY_VCO_CAL_LD3,
1638                         TXGBE_PHY_VCO_CAL_LD0_OTHER);
1639         /* Set VR XS, PMA, or MII Gen5 12G PHY VCO
1640          * Calibration Reference 0 Register Bit[5:0] = 6'd34  //VCO_REF_LD_0/1
1641          */
1642         wr32_epcs(hw, TXGBE_PHY_VCO_CAL_REF0, 0x2222);
1643
1644         /* Set VR XS, PMA, or MII Gen5 12G PHY VCO
1645          * Calibration Reference 1 Register Bit[5:0] = 6'd34  //VCO_REF_LD_2/3
1646          */
1647         wr32_epcs(hw, TXGBE_PHY_VCO_CAL_REF1, 0x2222);
1648
1649         /* Set VR XS, PMA, or MII Gen5 12G PHY AFE-DFE
1650          * Enable Register Bit[7:0] = 8'd0  //AFE_EN_0/3_1, DFE_EN_0/3_1
1651          */
1652         wr32_epcs(hw, TXGBE_PHY_AFE_DFE_ENABLE, 0x0);
1653
1654         /* Set  VR XS, PMA, or MII Gen5 12G PHY Rx
1655          * Equalization Control 4 Register Bit[3:0] = 4'd0  //CONT_ADAPT_0/3_1
1656          */
1657         wr32_epcs(hw, TXGBE_PHY_RX_EQ_CTL, 0x00F0);
1658
1659         /* Set VR XS, PMA, or MII Gen5 12G PHY Tx Rate
1660          * Control Register Bit[14:12], Bit[10:8], Bit[6:4], Bit[2:0],
1661          * all rates to 3'b010  //TX0/1/2/3_RATE
1662          */
1663         wr32_epcs(hw, TXGBE_PHY_TX_RATE_CTL, 0x2222);
1664
1665         /* Set VR XS, PMA, or MII Gen5 12G PHY Rx Rate
1666          * Control Register Bit[13:12], Bit[9:8], Bit[5:4], Bit[1:0],
1667          * all rates to 2'b10  //RX0/1/2/3_RATE
1668          */
1669         wr32_epcs(hw, TXGBE_PHY_RX_RATE_CTL, 0x2222);
1670
1671         /* Set VR XS, PMA, or MII Gen5 12G PHY Tx General
1672          * Control 2 Register Bit[15:8] = 2'b01  //TX0/1/2/3_WIDTH: 10bits
1673          */
1674         wr32_epcs(hw, TXGBE_PHY_TX_GEN_CTL2, 0x5500);
1675
1676         /* Set VR XS, PMA, or MII Gen5 12G PHY Rx General
1677          * Control 2 Register Bit[15:8] = 2'b01  //RX0/1/2/3_WIDTH: 10bits
1678          */
1679         wr32_epcs(hw, TXGBE_PHY_RX_GEN_CTL2, 0x5500);
1680
1681         /* Set VR XS, PMA, or MII Gen5 12G PHY MPLLA Control
1682          * 2 Register Bit[10:8] = 3'b010
1683          * MPLLA_DIV16P5_CLK_EN=0, MPLLA_DIV10_CLK_EN=1, MPLLA_DIV8_CLK_EN=0
1684          */
1685         wr32_epcs(hw, TXGBE_PHY_MPLLA_CTL2,
1686                         TXGBE_PHY_MPLLA_CTL2_DIV_CLK_EN_10);
1687
1688         wr32_epcs(hw, 0x1f0000, 0x0);
1689         wr32_epcs(hw, 0x1f8001, 0x0);
1690         wr32_epcs(hw, SR_MII_MMD_DIGI_CTL, 0x0);
1691
1692         /* 10. Initialize the mode by setting VR XS or PCS MMD Digital Control1
1693          * Register Bit[15](VR_RST)
1694          */
1695         wr32_epcs(hw, VR_XS_OR_PCS_MMD_DIGI_CTL1, 0xA000);
1696
1697         /* Wait phy initialization done */
1698         for (i = 0; i < 100; i++) {
1699                 if ((rd32_epcs(hw, VR_XS_OR_PCS_MMD_DIGI_CTL1) &
1700                         VR_XS_OR_PCS_MMD_DIGI_CTL1_VR_RST) == 0)
1701                         break;
1702                 msleep(100);
1703         }
1704
1705         /* If success, set link status */
1706         hw->link_status = TXGBE_LINK_STATUS_KX4;
1707
1708         if (i == 100) {
1709                 err = TXGBE_ERR_PHY_INIT_NOT_DONE;
1710                 goto out;
1711         }
1712
1713         if (hw->fw_version <= TXGBE_FW_N_TXEQ) {
1714                 value = (0x1804 & ~0x3F3F);
1715                 wr32_epcs(hw, TXGBE_PHY_TX_EQ_CTL0, value);
1716
1717                 value = (0x50 & ~0x7F) | 40 | (1 << 6);
1718                 wr32_epcs(hw, TXGBE_PHY_TX_EQ_CTL1, value);
1719         }
1720 out:
1721         return err;
1722 }
1723
1724 static s32
1725 txgbe_set_link_to_kx(struct txgbe_hw *hw,
1726                                u32 speed,
1727                                bool autoneg)
1728 {
1729         u32 i;
1730         s32 err = 0;
1731         u32 wdata = 0;
1732         u32 value;
1733
1734         /* Check link status, if already set, skip setting it again */
1735         if (hw->link_status == TXGBE_LINK_STATUS_KX)
1736                 goto out;
1737
1738         BP_LOG("It is set to kx. speed =0x%x\n", speed);
1739         wr32_epcs(hw, TXGBE_PHY_TX_POWER_ST_CTL, 0x00FC);
1740         wr32_epcs(hw, TXGBE_PHY_RX_POWER_ST_CTL, 0x00FC);
1741
1742         /* 1. Wait xpcs power-up good */
1743         for (i = 0; i < 100; i++) {
1744                 if ((rd32_epcs(hw, VR_XS_OR_PCS_MMD_DIGI_STATUS) &
1745                         VR_XS_OR_PCS_MMD_DIGI_STATUS_PSEQ_MASK) ==
1746                         VR_XS_OR_PCS_MMD_DIGI_STATUS_PSEQ_POWER_GOOD)
1747                         break;
1748                 msec_delay(10);
1749         }
1750         if (i == 100) {
1751                 err = TXGBE_ERR_XPCS_POWER_UP_FAILED;
1752                 goto out;
1753         }
1754
1755         wr32m(hw, TXGBE_MACTXCFG, TXGBE_MACTXCFG_TXE,
1756                                 ~TXGBE_MACTXCFG_TXE);
1757
1758         /* 2. Disable xpcs AN-73 */
1759         if (!autoneg)
1760                 wr32_epcs(hw, SR_AN_CTRL, 0x0);
1761         else
1762                 wr32_epcs(hw, SR_AN_CTRL, 0x3000);
1763
1764         /* Disable PHY MPLLA for eth mode change(after ECO) */
1765         wr32_ephy(hw, 0x4, 0x240A);
1766         txgbe_flush(hw);
1767         msec_delay(1);
1768
1769         /* Set the eth change_mode bit first in mis_rst register
1770          * for corresponding LAN port
1771          */
1772         wr32(hw, TXGBE_RST, TXGBE_RST_ETH(hw->bus.lan_id));
1773
1774         /* Set SR PCS Control2 Register Bits[1:0] = 2'b01
1775          * PCS_TYPE_SEL: non KR
1776          */
1777         wr32_epcs(hw, SR_XS_PCS_CTRL2,
1778                         SR_PCS_CTRL2_TYPE_SEL_X);
1779
1780         /* Set SR PMA MMD Control1 Register Bit[13] = 1'b0
1781          * SS13: 1G speed
1782          */
1783         wr32_epcs(hw, SR_PMA_CTRL1,
1784                         SR_PMA_CTRL1_SS13_KX);
1785
1786         /* Set SR MII MMD Control Register to corresponding speed: {Bit[6],
1787          * Bit[13]}=[2'b00,2'b01,2'b10]->[10M,100M,1G]
1788          */
1789         if (speed == TXGBE_LINK_SPEED_100M_FULL)
1790                 wdata = 0x2100;
1791         else if (speed == TXGBE_LINK_SPEED_1GB_FULL)
1792                 wdata = 0x0140;
1793         else if (speed == TXGBE_LINK_SPEED_10M_FULL)
1794                 wdata = 0x0100;
1795         wr32_epcs(hw, SR_MII_MMD_CTL,
1796                         wdata);
1797
1798         value = (0xf5f0 & ~0x710) | (0x5 << 8) | 0x10;
1799         wr32_epcs(hw, TXGBE_PHY_TX_GENCTRL1, value);
1800
1801         if (hw->devarg.sgmii == 1)
1802                 wr32_epcs(hw, TXGBE_PHY_MISC_CTL0, 0x4F00);
1803         else
1804                 wr32_epcs(hw, TXGBE_PHY_MISC_CTL0, 0xCF00);
1805
1806         for (i = 0; i < 4; i++) {
1807                 if (i) {
1808                         value = 0xff06;
1809                 } else {
1810                         value = (0x45 & ~0xFFFF) | (0x7 << 12) |
1811                                 (0x7 << 8) | 0x6;
1812                 }
1813                 wr32_epcs(hw, TXGBE_PHY_RX_EQ_CTL0 + i, value);
1814         }
1815
1816         value = 0x0 & ~0x7;
1817         wr32_epcs(hw, TXGBE_PHY_RX_EQ_ATT_LVL0, value);
1818
1819         wr32_epcs(hw, TXGBE_PHY_DFE_TAP_CTL0, 0x0);
1820
1821         value = (0x6db & ~0x7) | 0x4;
1822         wr32_epcs(hw, TXGBE_PHY_RX_GEN_CTL3, value);
1823
1824         /* Set VR XS, PMA, or MII Gen5 12G PHY MPLLA Control
1825          * 0 Register Bit[7:0] = 8'd32  //MPLLA_MULTIPLIER
1826          */
1827         wr32_epcs(hw, TXGBE_PHY_MPLLA_CTL0,
1828                         TXGBE_PHY_MPLLA_CTL0_MULTIPLIER_1GBASEX_KX);
1829
1830         /* Set VR XS, PMA or MII Gen5 12G PHY MPLLA Control
1831          * 3 Register Bit[10:0] = 11'd70  //MPLLA_BANDWIDTH
1832          */
1833         wr32_epcs(hw, TXGBE_PHY_MPLLA_CTL3,
1834                         TXGBE_PHY_MPLLA_CTL3_MULTIPLIER_BW_1GBASEX_KX);
1835
1836         /* Set VR XS, PMA, or MII Gen5 12G PHY VCO
1837          * Calibration Load 0 Register  Bit[12:0] = 13'd1344  //VCO_LD_VAL_0
1838          */
1839         wr32_epcs(hw, TXGBE_PHY_VCO_CAL_LD0,
1840                         TXGBE_PHY_VCO_CAL_LD0_1GBASEX_KX);
1841
1842         wr32_epcs(hw, TXGBE_PHY_VCO_CAL_LD1, 0x549);
1843         wr32_epcs(hw, TXGBE_PHY_VCO_CAL_LD2, 0x549);
1844         wr32_epcs(hw, TXGBE_PHY_VCO_CAL_LD3, 0x549);
1845
1846         /* Set VR XS, PMA, or MII Gen5 12G PHY VCO
1847          * Calibration Reference 0 Register Bit[5:0] = 6'd42  //VCO_REF_LD_0
1848          */
1849         wr32_epcs(hw, TXGBE_PHY_VCO_CAL_REF0,
1850                         TXGBE_PHY_VCO_CAL_REF0_LD0_1GBASEX_KX);
1851
1852         wr32_epcs(hw, TXGBE_PHY_VCO_CAL_REF1, 0x2929);
1853
1854         /* Set VR XS, PMA, or MII Gen5 12G PHY AFE-DFE
1855          * Enable Register Bit[4], Bit[0] = 1'b0  //AFE_EN_0, DFE_EN_0
1856          */
1857         wr32_epcs(hw, TXGBE_PHY_AFE_DFE_ENABLE,
1858                         0x0);
1859         /* Set VR XS, PMA, or MII Gen5 12G PHY Rx
1860          * Equalization Control 4 Register Bit[0] = 1'b0  //CONT_ADAPT_0
1861          */
1862         wr32_epcs(hw, TXGBE_PHY_RX_EQ_CTL,
1863                         0x0010);
1864         /* Set VR XS, PMA, or MII Gen5 12G PHY Tx Rate
1865          * Control Register Bit[2:0] = 3'b011  //TX0_RATE
1866          */
1867         wr32_epcs(hw, TXGBE_PHY_TX_RATE_CTL,
1868                         TXGBE_PHY_TX_RATE_CTL_TX0_RATE_1GBASEX_KX);
1869
1870         /* Set VR XS, PMA, or MII Gen5 12G PHY Rx Rate
1871          * Control Register Bit[2:0] = 3'b011 //RX0_RATE
1872          */
1873         wr32_epcs(hw, TXGBE_PHY_RX_RATE_CTL,
1874                         TXGBE_PHY_RX_RATE_CTL_RX0_RATE_1GBASEX_KX);
1875
1876         /* Set VR XS, PMA, or MII Gen5 12G PHY Tx General
1877          * Control 2 Register Bit[9:8] = 2'b01  //TX0_WIDTH: 10bits
1878          */
1879         wr32_epcs(hw, TXGBE_PHY_TX_GEN_CTL2,
1880                         TXGBE_PHY_TX_GEN_CTL2_TX0_WIDTH_OTHER);
1881         /* Set VR XS, PMA, or MII Gen5 12G PHY Rx General
1882          * Control 2 Register Bit[9:8] = 2'b01  //RX0_WIDTH: 10bits
1883          */
1884         wr32_epcs(hw, TXGBE_PHY_RX_GEN_CTL2,
1885                         TXGBE_PHY_RX_GEN_CTL2_RX0_WIDTH_OTHER);
1886         /* Set VR XS, PMA, or MII Gen5 12G PHY MPLLA Control
1887          * 2 Register Bit[10:8] = 3'b010   //MPLLA_DIV16P5_CLK_EN=0,
1888          * MPLLA_DIV10_CLK_EN=1, MPLLA_DIV8_CLK_EN=0
1889          */
1890         wr32_epcs(hw, TXGBE_PHY_MPLLA_CTL2,
1891                         TXGBE_PHY_MPLLA_CTL2_DIV_CLK_EN_10);
1892
1893         /* VR MII MMD AN Control Register Bit[8] = 1'b1 //MII_CTRL
1894          * Set to 8bit MII (required in 10M/100M SGMII)
1895          */
1896         wr32_epcs(hw, SR_MII_MMD_AN_CTL,
1897                         0x0100);
1898
1899         /* 10. Initialize the mode by setting VR XS or PCS MMD Digital Control1
1900          * Register Bit[15](VR_RST)
1901          */
1902         wr32_epcs(hw, VR_XS_OR_PCS_MMD_DIGI_CTL1, 0xA000);
1903
1904         /* Wait phy initialization done */
1905         for (i = 0; i < 100; i++) {
1906                 if ((rd32_epcs(hw, VR_XS_OR_PCS_MMD_DIGI_CTL1) &
1907                         VR_XS_OR_PCS_MMD_DIGI_CTL1_VR_RST) == 0)
1908                         break;
1909                 msleep(100);
1910         }
1911
1912         /* If success, set link status */
1913         hw->link_status = TXGBE_LINK_STATUS_KX;
1914
1915         if (i == 100) {
1916                 err = TXGBE_ERR_PHY_INIT_NOT_DONE;
1917                 goto out;
1918         }
1919
1920         if (hw->fw_version <= TXGBE_FW_N_TXEQ) {
1921                 value = (0x1804 & ~0x3F3F) | (24 << 8) | 4;
1922                 wr32_epcs(hw, TXGBE_PHY_TX_EQ_CTL0, value);
1923
1924                 value = (0x50 & ~0x7F) | 16 | (1 << 6);
1925                 wr32_epcs(hw, TXGBE_PHY_TX_EQ_CTL1, value);
1926         }
1927 out:
1928         return err;
1929 }
1930
1931 static s32
1932 txgbe_set_link_to_sfi(struct txgbe_hw *hw,
1933                                u32 speed)
1934 {
1935         u32 i;
1936         s32 err = 0;
1937         u32 value = 0;
1938
1939         /* Set the module link speed */
1940         hw->mac.set_rate_select_speed(hw, speed);
1941         /* 1. Wait xpcs power-up good */
1942         for (i = 0; i < 100; i++) {
1943                 if ((rd32_epcs(hw, VR_XS_OR_PCS_MMD_DIGI_STATUS) &
1944                         VR_XS_OR_PCS_MMD_DIGI_STATUS_PSEQ_MASK) ==
1945                         VR_XS_OR_PCS_MMD_DIGI_STATUS_PSEQ_POWER_GOOD)
1946                         break;
1947                 msec_delay(10);
1948         }
1949         if (i == 100) {
1950                 err = TXGBE_ERR_XPCS_POWER_UP_FAILED;
1951                 goto out;
1952         }
1953
1954         wr32m(hw, TXGBE_MACTXCFG, TXGBE_MACTXCFG_TXE,
1955                         ~TXGBE_MACTXCFG_TXE);
1956
1957         /* 2. Disable xpcs AN-73 */
1958         wr32_epcs(hw, SR_AN_CTRL, 0x0);
1959
1960         /* Disable PHY MPLLA for eth mode change(after ECO) */
1961         wr32_ephy(hw, 0x4, 0x243A);
1962         txgbe_flush(hw);
1963         msec_delay(1);
1964         /* Set the eth change_mode bit first in mis_rst register
1965          * for corresponding LAN port
1966          */
1967         wr32(hw, TXGBE_RST, TXGBE_RST_ETH(hw->bus.lan_id));
1968
1969         if (speed == TXGBE_LINK_SPEED_10GB_FULL) {
1970                 /* Set SR PCS Control2 Register Bits[1:0] = 2'b00
1971                  * PCS_TYPE_SEL: KR
1972                  */
1973                 wr32_epcs(hw, SR_XS_PCS_CTRL2, 0);
1974                 value = rd32_epcs(hw, SR_PMA_CTRL1);
1975                 value = value | 0x2000;
1976                 wr32_epcs(hw, SR_PMA_CTRL1, value);
1977                 /* Set VR_XS_PMA_Gen5_12G_MPLLA_CTRL0 Register Bit[7:0] = 8'd33
1978                  * MPLLA_MULTIPLIER
1979                  */
1980                 wr32_epcs(hw, TXGBE_PHY_MPLLA_CTL0, 0x0021);
1981                 /* 3. Set VR_XS_PMA_Gen5_12G_MPLLA_CTRL3 Register
1982                  * Bit[10:0](MPLLA_BANDWIDTH) = 11'd0
1983                  */
1984                 wr32_epcs(hw, TXGBE_PHY_MPLLA_CTL3, 0);
1985                 value = rd32_epcs(hw, TXGBE_PHY_TX_GENCTRL1);
1986                 value = (value & ~0x700) | 0x500;
1987                 wr32_epcs(hw, TXGBE_PHY_TX_GENCTRL1, value);
1988                 /* 4. Set VR_XS_PMA_Gen5_12G_MISC_CTRL0 Register
1989                  * Bit[12:8](RX_VREF_CTRL) = 5'hF
1990                  */
1991                 wr32_epcs(hw, TXGBE_PHY_MISC_CTL0, 0xCF00);
1992                 /* Set VR_XS_PMA_Gen5_12G_VCO_CAL_LD0 Register
1993                  * Bit[12:0] = 13'd1353  //VCO_LD_VAL_0
1994                  */
1995                 wr32_epcs(hw, TXGBE_PHY_VCO_CAL_LD0, 0x0549);
1996                 /* Set VR_XS_PMA_Gen5_12G_VCO_CAL_REF0 Register
1997                  * Bit[5:0] = 6'd41  //VCO_REF_LD_0
1998                  */
1999                 wr32_epcs(hw, TXGBE_PHY_VCO_CAL_REF0, 0x0029);
2000                 /* Set VR_XS_PMA_Gen5_12G_TX_RATE_CTRL Register
2001                  * Bit[2:0] = 3'b000  //TX0_RATE
2002                  */
2003                 wr32_epcs(hw, TXGBE_PHY_TX_RATE_CTL, 0);
2004                 /* Set VR_XS_PMA_Gen5_12G_RX_RATE_CTRL Register
2005                  * Bit[2:0] = 3'b000  //RX0_RATE
2006                  */
2007                 wr32_epcs(hw, TXGBE_PHY_RX_RATE_CTL, 0);
2008                 /* Set VR_XS_PMA_Gen5_12G_TX_GENCTRL2 Register Bit[9:8] = 2'b11
2009                  * TX0_WIDTH: 20bits
2010                  */
2011                 wr32_epcs(hw, TXGBE_PHY_TX_GEN_CTL2, 0x0300);
2012                 /* Set VR_XS_PMA_Gen5_12G_RX_GENCTRL2 Register Bit[9:8] = 2'b11
2013                  * RX0_WIDTH: 20bits
2014                  */
2015                 wr32_epcs(hw, TXGBE_PHY_RX_GEN_CTL2, 0x0300);
2016                 /* Set VR_XS_PMA_Gen5_12G_MPLLA_CTRL2 Register
2017                  * Bit[10:8] = 3'b110
2018                  * MPLLA_DIV16P5_CLK_EN=1
2019                  * MPLLA_DIV10_CLK_EN=1
2020                  * MPLLA_DIV8_CLK_EN=0
2021                  */
2022                 wr32_epcs(hw, TXGBE_PHY_MPLLA_CTL2, 0x0600);
2023
2024                 if (hw->phy.sfp_type == txgbe_sfp_type_da_cu_core0 ||
2025                         hw->phy.sfp_type == txgbe_sfp_type_da_cu_core1) {
2026                         /* 7. Set VR_XS_PMA_Gen5_12G_RX_EQ_CTRL0 Register
2027                          * Bit[15:8](VGA1/2_GAIN_0) = 8'h77
2028                          * Bit[7:5](CTLE_POLE_0) = 3'h2
2029                          * Bit[4:0](CTLE_BOOST_0) = 4'hF
2030                          */
2031                         wr32_epcs(hw, TXGBE_PHY_RX_EQ_CTL0, 0x774F);
2032
2033                 } else {
2034                         /* 7. Set VR_XS_PMA_Gen5_12G_RX_EQ_CTRL0 Register
2035                          * Bit[15:8](VGA1/2_GAIN_0) = 8'h00
2036                          * Bit[7:5](CTLE_POLE_0) = 3'h2
2037                          * Bit[4:0](CTLE_BOOST_0) = 4'hA
2038                          */
2039                         value = rd32_epcs(hw, TXGBE_PHY_RX_EQ_CTL0);
2040                         value = (value & ~0xFFFF) | (2 << 5) | 0x05;
2041                         wr32_epcs(hw, TXGBE_PHY_RX_EQ_CTL0, value);
2042                 }
2043                 value = rd32_epcs(hw, TXGBE_PHY_RX_EQ_ATT_LVL0);
2044                 value = (value & ~0x7) | 0x0;
2045                 wr32_epcs(hw, TXGBE_PHY_RX_EQ_ATT_LVL0, value);
2046
2047                 if (hw->phy.sfp_type == txgbe_sfp_type_da_cu_core0 ||
2048                         hw->phy.sfp_type == txgbe_sfp_type_da_cu_core1) {
2049                         /* 8. Set VR_XS_PMA_Gen5_12G_DFE_TAP_CTRL0 Register
2050                          * Bit[7:0](DFE_TAP1_0) = 8'd20
2051                          */
2052                         wr32_epcs(hw, TXGBE_PHY_DFE_TAP_CTL0, 0x0014);
2053                         value = rd32_epcs(hw, TXGBE_PHY_AFE_DFE_ENABLE);
2054                         value = (value & ~0x11) | 0x11;
2055                         wr32_epcs(hw, TXGBE_PHY_AFE_DFE_ENABLE, value);
2056                 } else {
2057                         /* 8. Set VR_XS_PMA_Gen5_12G_DFE_TAP_CTRL0 Register
2058                          * Bit[7:0](DFE_TAP1_0) = 8'd20
2059                          */
2060                         wr32_epcs(hw, TXGBE_PHY_DFE_TAP_CTL0, 0xBE);
2061                         /* 9. Set VR_MII_Gen5_12G_AFE_DFE_EN_CTRL Register
2062                          * Bit[4](DFE_EN_0) = 1'b0, Bit[0](AFE_EN_0) = 1'b0
2063                          */
2064                         value = rd32_epcs(hw, TXGBE_PHY_AFE_DFE_ENABLE);
2065                         value = (value & ~0x11) | 0x0;
2066                         wr32_epcs(hw, TXGBE_PHY_AFE_DFE_ENABLE, value);
2067                 }
2068                 value = rd32_epcs(hw, TXGBE_PHY_RX_EQ_CTL);
2069                 value = value & ~0x1;
2070                 wr32_epcs(hw, TXGBE_PHY_RX_EQ_CTL, value);
2071         } else {
2072                 /* Set SR PCS Control2 Register Bits[1:0] = 2'b00
2073                  * PCS_TYPE_SEL: KR
2074                  */
2075                 wr32_epcs(hw, SR_XS_PCS_CTRL2, 0x1);
2076                 /* Set SR PMA MMD Control1 Register Bit[13] = 1'b0
2077                  * SS13: 1G speed
2078                  */
2079                 wr32_epcs(hw, SR_PMA_CTRL1, 0x0000);
2080                 /* Set SR MII MMD Control Register to corresponding speed */
2081                 wr32_epcs(hw, SR_MII_MMD_CTL, 0x0140);
2082
2083                 value = rd32_epcs(hw, TXGBE_PHY_TX_GENCTRL1);
2084                 value = (value & ~0x710) | 0x500;
2085                 wr32_epcs(hw, TXGBE_PHY_TX_GENCTRL1, value);
2086                 /* 4. Set VR_XS_PMA_Gen5_12G_MISC_CTRL0 Register
2087                  * Bit[12:8](RX_VREF_CTRL) = 5'hF
2088                  */
2089                 wr32_epcs(hw, TXGBE_PHY_MISC_CTL0, 0xCF00);
2090
2091                 if (hw->phy.sfp_type == txgbe_sfp_type_da_cu_core0 ||
2092                         hw->phy.sfp_type == txgbe_sfp_type_da_cu_core1) {
2093                         wr32_epcs(hw, TXGBE_PHY_RX_EQ_CTL0, 0x774F);
2094                 } else {
2095                         /* 7. Set VR_XS_PMA_Gen5_12G_RX_EQ_CTRL0 Register
2096                          * Bit[15:8](VGA1/2_GAIN_0) = 8'h00
2097                          * Bit[7:5](CTLE_POLE_0) = 3'h2
2098                          * Bit[4:0](CTLE_BOOST_0) = 4'hA
2099                          */
2100                         value = rd32_epcs(hw, TXGBE_PHY_RX_EQ_CTL0);
2101                         value = (value & ~0xFFFF) | 0x7706;
2102                         wr32_epcs(hw, TXGBE_PHY_RX_EQ_CTL0, value);
2103                 }
2104                 value = rd32_epcs(hw, TXGBE_PHY_RX_EQ_ATT_LVL0);
2105                 value = (value & ~0x7) | 0x0;
2106                 wr32_epcs(hw, TXGBE_PHY_RX_EQ_ATT_LVL0, value);
2107                 /* 8. Set VR_XS_PMA_Gen5_12G_DFE_TAP_CTRL0 Register
2108                  * Bit[7:0](DFE_TAP1_0) = 8'd00
2109                  */
2110                 wr32_epcs(hw, TXGBE_PHY_DFE_TAP_CTL0, 0x0);
2111                 /* 9. Set VR_MII_Gen5_12G_AFE_DFE_EN_CTRL Register
2112                  * Bit[4](DFE_EN_0) = 1'b0, Bit[0](AFE_EN_0) = 1'b0
2113                  */
2114                 value = rd32_epcs(hw, TXGBE_PHY_RX_GEN_CTL3);
2115                 value = (value & ~0x7) | 0x4;
2116                 wr32_epcs(hw, TXGBE_PHY_RX_GEN_CTL3, value);
2117                 wr32_epcs(hw, TXGBE_PHY_MPLLA_CTL0, 0x0020);
2118                 wr32_epcs(hw, TXGBE_PHY_MPLLA_CTL3, 0x0046);
2119                 wr32_epcs(hw, TXGBE_PHY_VCO_CAL_LD0, 0x0540);
2120                 wr32_epcs(hw, TXGBE_PHY_VCO_CAL_REF0, 0x002A);
2121                 wr32_epcs(hw, TXGBE_PHY_AFE_DFE_ENABLE, 0x0);
2122                 wr32_epcs(hw, TXGBE_PHY_RX_EQ_CTL, 0x0010);
2123                 wr32_epcs(hw, TXGBE_PHY_TX_RATE_CTL, 0x0003);
2124                 wr32_epcs(hw, TXGBE_PHY_RX_RATE_CTL, 0x0003);
2125                 wr32_epcs(hw, TXGBE_PHY_TX_GEN_CTL2, 0x0100);
2126                 wr32_epcs(hw, TXGBE_PHY_RX_GEN_CTL2, 0x0100);
2127                 wr32_epcs(hw, TXGBE_PHY_MPLLA_CTL2, 0x0200);
2128                 wr32_epcs(hw, SR_MII_MMD_AN_CTL, 0x0100);
2129         }
2130         /* 10. Initialize the mode by setting VR XS or PCS MMD Digital Control1
2131          * Register Bit[15](VR_RST)
2132          */
2133         wr32_epcs(hw, VR_XS_OR_PCS_MMD_DIGI_CTL1, 0xA000);
2134
2135         /* Wait phy initialization done */
2136         for (i = 0; i < 100; i++) {
2137                 if ((rd32_epcs(hw, VR_XS_OR_PCS_MMD_DIGI_CTL1) &
2138                         VR_XS_OR_PCS_MMD_DIGI_CTL1_VR_RST) == 0)
2139                         break;
2140                 msleep(100);
2141         }
2142         if (i == 100) {
2143                 err = TXGBE_ERR_PHY_INIT_NOT_DONE;
2144                 goto out;
2145         }
2146
2147         if (hw->fw_version <= TXGBE_FW_N_TXEQ) {
2148                 value = rd32_epcs(hw, TXGBE_PHY_TX_EQ_CTL0);
2149                 value = (value & ~0x3F3F) | (24 << 8) | 4;
2150                 wr32_epcs(hw, TXGBE_PHY_TX_EQ_CTL0, value);
2151
2152                 value = rd32_epcs(hw, TXGBE_PHY_TX_EQ_CTL1);
2153                 value = (value & ~0x7F) | 16 | (1 << 6);
2154                 wr32_epcs(hw, TXGBE_PHY_TX_EQ_CTL1, value);
2155         }
2156 out:
2157         return err;
2158 }
2159
2160 /**
2161  *  txgbe_autoc_read - Hides MAC differences needed for AUTOC read
2162  *  @hw: pointer to hardware structure
2163  */
2164 u64 txgbe_autoc_read(struct txgbe_hw *hw)
2165 {
2166         u64 autoc;
2167         u32 sr_pcs_ctl;
2168         u32 sr_pma_ctl1;
2169         u32 sr_an_ctl;
2170         u32 sr_an_adv_reg2;
2171         u8 type = hw->subsystem_device_id & 0xFF;
2172
2173         autoc = hw->mac.autoc;
2174
2175         if (hw->phy.multispeed_fiber) {
2176                 autoc |= TXGBE_AUTOC_LMS_10G;
2177         } else if (type == TXGBE_DEV_ID_SFP) {
2178                 autoc |= TXGBE_AUTOC_LMS_10G;
2179                 autoc |= TXGBE_AUTOC_10GS_SFI;
2180         } else if (type == TXGBE_DEV_ID_QSFP) {
2181                 autoc = 0; /*TBD*/
2182         } else if (type == TXGBE_DEV_ID_XAUI || type == TXGBE_DEV_ID_SFI_XAUI) {
2183                 autoc |= TXGBE_AUTOC_LMS_10G_LINK_NO_AN;
2184                 autoc |= TXGBE_AUTOC_10G_XAUI;
2185                 hw->phy.link_mode = TXGBE_PHYSICAL_LAYER_10GBASE_T;
2186         } else if (type == TXGBE_DEV_ID_SGMII) {
2187                 autoc |= TXGBE_AUTOC_LMS_SGMII_1G_100M;
2188                 hw->phy.link_mode = TXGBE_PHYSICAL_LAYER_1000BASE_T |
2189                                 TXGBE_PHYSICAL_LAYER_100BASE_TX;
2190         } else if (type == TXGBE_DEV_ID_MAC_XAUI) {
2191                 autoc |= TXGBE_AUTOC_LMS_10G_LINK_NO_AN;
2192                 hw->phy.link_mode = TXGBE_PHYSICAL_LAYER_10GBASE_KX4;
2193         } else if (type == TXGBE_DEV_ID_MAC_SGMII) {
2194                 autoc |= TXGBE_AUTOC_LMS_1G_LINK_NO_AN;
2195                 hw->phy.link_mode = TXGBE_PHYSICAL_LAYER_1000BASE_KX;
2196         }
2197
2198         if (type != TXGBE_DEV_ID_KR_KX_KX4)
2199                 return autoc;
2200
2201         sr_pcs_ctl = rd32_epcs(hw, SR_XS_PCS_CTRL2);
2202         sr_pma_ctl1 = rd32_epcs(hw, SR_PMA_CTRL1);
2203         sr_an_ctl = rd32_epcs(hw, SR_AN_CTRL);
2204         sr_an_adv_reg2 = rd32_epcs(hw, SR_AN_MMD_ADV_REG2);
2205
2206         if ((sr_pcs_ctl & SR_PCS_CTRL2_TYPE_SEL) == SR_PCS_CTRL2_TYPE_SEL_X &&
2207             (sr_pma_ctl1 & SR_PMA_CTRL1_SS13) == SR_PMA_CTRL1_SS13_KX &&
2208             (sr_an_ctl & SR_AN_CTRL_AN_EN) == 0) {
2209                 /* 1G or KX - no backplane auto-negotiation */
2210                 autoc |= TXGBE_AUTOC_LMS_1G_LINK_NO_AN |
2211                          TXGBE_AUTOC_1G_KX;
2212                 hw->phy.link_mode = TXGBE_PHYSICAL_LAYER_1000BASE_KX;
2213         } else if ((sr_pcs_ctl & SR_PCS_CTRL2_TYPE_SEL) ==
2214                 SR_PCS_CTRL2_TYPE_SEL_X &&
2215                 (sr_pma_ctl1 & SR_PMA_CTRL1_SS13) == SR_PMA_CTRL1_SS13_KX4 &&
2216                 (sr_an_ctl & SR_AN_CTRL_AN_EN) == 0) {
2217                 autoc |= TXGBE_AUTOC_LMS_10G |
2218                          TXGBE_AUTOC_10G_KX4;
2219                 hw->phy.link_mode = TXGBE_PHYSICAL_LAYER_10GBASE_KX4;
2220         } else if ((sr_pcs_ctl & SR_PCS_CTRL2_TYPE_SEL) ==
2221                 SR_PCS_CTRL2_TYPE_SEL_R &&
2222                 (sr_an_ctl & SR_AN_CTRL_AN_EN) == 0) {
2223                 /* 10 GbE serial link (KR -no backplane auto-negotiation) */
2224                 autoc |= TXGBE_AUTOC_LMS_10G |
2225                          TXGBE_AUTOC_10GS_KR;
2226                 hw->phy.link_mode = TXGBE_PHYSICAL_LAYER_10GBASE_KR;
2227         } else if ((sr_an_ctl & SR_AN_CTRL_AN_EN)) {
2228                 /* KX/KX4/KR backplane auto-negotiation enable */
2229                 if (sr_an_adv_reg2 & SR_AN_MMD_ADV_REG2_BP_TYPE_KR)
2230                         autoc |= TXGBE_AUTOC_KR_SUPP;
2231                 if (sr_an_adv_reg2 & SR_AN_MMD_ADV_REG2_BP_TYPE_KX4)
2232                         autoc |= TXGBE_AUTOC_KX4_SUPP;
2233                 if (sr_an_adv_reg2 & SR_AN_MMD_ADV_REG2_BP_TYPE_KX)
2234                         autoc |= TXGBE_AUTOC_KX_SUPP;
2235                 autoc |= TXGBE_AUTOC_LMS_KX4_KX_KR;
2236                 hw->phy.link_mode = TXGBE_PHYSICAL_LAYER_10GBASE_KR |
2237                                 TXGBE_PHYSICAL_LAYER_10GBASE_KX4 |
2238                                 TXGBE_PHYSICAL_LAYER_1000BASE_KX;
2239         }
2240
2241         return autoc;
2242 }
2243
2244 /**
2245  * txgbe_autoc_write - Hides MAC differences needed for AUTOC write
2246  * @hw: pointer to hardware structure
2247  * @autoc: value to write to AUTOC
2248  */
2249 void txgbe_autoc_write(struct txgbe_hw *hw, u64 autoc)
2250 {
2251         bool autoneg;
2252         u32 speed;
2253         u32 mactxcfg = 0;
2254         u8 device_type = hw->subsystem_device_id & 0xFF;
2255
2256         speed = TXGBD_AUTOC_SPEED(autoc);
2257         autoc &= ~TXGBE_AUTOC_SPEED_MASK;
2258         autoneg = (autoc & TXGBE_AUTOC_AUTONEG ? true : false);
2259         autoc &= ~TXGBE_AUTOC_AUTONEG;
2260
2261         if (device_type == TXGBE_DEV_ID_KR_KX_KX4) {
2262                 if (!autoneg) {
2263                         switch (hw->phy.link_mode) {
2264                         case TXGBE_PHYSICAL_LAYER_10GBASE_KR:
2265                                 txgbe_set_link_to_kr(hw, autoneg);
2266                                 break;
2267                         case TXGBE_PHYSICAL_LAYER_10GBASE_KX4:
2268                                 txgbe_set_link_to_kx4(hw, autoneg);
2269                                 break;
2270                         case TXGBE_PHYSICAL_LAYER_1000BASE_KX:
2271                                 txgbe_set_link_to_kx(hw, speed, autoneg);
2272                                 break;
2273                         default:
2274                                 return;
2275                         }
2276                 } else {
2277                         txgbe_set_link_to_kr(hw, !autoneg);
2278                 }
2279         } else if (device_type == TXGBE_DEV_ID_XAUI ||
2280                    device_type == TXGBE_DEV_ID_SGMII ||
2281                    device_type == TXGBE_DEV_ID_MAC_XAUI ||
2282                    device_type == TXGBE_DEV_ID_MAC_SGMII ||
2283                    (device_type == TXGBE_DEV_ID_SFI_XAUI &&
2284                    hw->phy.media_type == txgbe_media_type_copper)) {
2285                 if (speed == TXGBE_LINK_SPEED_10GB_FULL) {
2286                         txgbe_set_link_to_kx4(hw, 0);
2287                 } else {
2288                         txgbe_set_link_to_kx(hw, speed, 0);
2289                         if (hw->devarg.auto_neg == 1)
2290                                 txgbe_set_sgmii_an37_ability(hw);
2291                 }
2292         } else if (hw->phy.media_type == txgbe_media_type_fiber) {
2293                 txgbe_set_link_to_sfi(hw, speed);
2294         }
2295
2296         if (speed == TXGBE_LINK_SPEED_10GB_FULL)
2297                 mactxcfg = TXGBE_MACTXCFG_SPEED_10G;
2298         else if (speed == TXGBE_LINK_SPEED_1GB_FULL)
2299                 mactxcfg = TXGBE_MACTXCFG_SPEED_1G;
2300
2301         /* enable mac transmitter */
2302         wr32m(hw, TXGBE_MACTXCFG,
2303                 TXGBE_MACTXCFG_SPEED_MASK | TXGBE_MACTXCFG_TXE,
2304                 mactxcfg | TXGBE_MACTXCFG_TXE);
2305 }
2306
2307 /**
2308  * txgbe_kr_handle - Handle the interrupt of auto-negotiation
2309  * @hw: pointer to hardware structure
2310  */
2311 s32 txgbe_kr_handle(struct txgbe_hw *hw)
2312 {
2313         u32 value;
2314         s32 status = 0;
2315
2316         DEBUGFUNC("txgbe_kr_handle");
2317
2318         value = rd32_epcs(hw, VR_AN_INTR);
2319         BP_LOG("AN INTERRUPT!! value: 0x%x\n", value);
2320         if (!(value & VR_AN_INTR_PG_RCV)) {
2321                 wr32_epcs(hw, VR_AN_INTR, 0);
2322                 return status;
2323         }
2324
2325         status = txgbe_handle_bp_flow(0, hw);
2326
2327         return status;
2328 }
2329
2330 /**
2331  * txgbe_handle_bp_flow - Handle backplane AN73 flow
2332  * @hw: pointer to hardware structure
2333  * @link_mode: local AN73 link mode
2334  */
2335 static s32 txgbe_handle_bp_flow(u32 link_mode, struct txgbe_hw *hw)
2336 {
2337         u32 value, i, lp_reg, ld_reg;
2338         s32 status = 0;
2339         struct txgbe_backplane_ability local_ability, lp_ability;
2340
2341         DEBUGFUNC("txgbe_handle_bp_flow");
2342
2343         local_ability.current_link_mode = link_mode;
2344
2345         /* 1. Get the local AN73 Base Page Ability */
2346         BP_LOG("<1>. Get the local AN73 Base Page Ability ...\n");
2347         txgbe_get_bp_ability(&local_ability, 0, hw);
2348
2349         /* 2. Check and clear the AN73 Interrupt Status */
2350         BP_LOG("<2>. Check the AN73 Interrupt Status ...\n");
2351         txgbe_clear_bp_intr(2, 0, hw);
2352
2353         /* 3.1. Get the link partner AN73 Base Page Ability */
2354         BP_LOG("<3.1>. Get the link partner AN73 Base Page Ability ...\n");
2355         txgbe_get_bp_ability(&lp_ability, 1, hw);
2356
2357         /* 3.2. Check the AN73 Link Ability with Link Partner */
2358         BP_LOG("<3.2>. Check the AN73 Link Ability with Link Partner ...\n");
2359         BP_LOG("       Local Link Ability: 0x%x\n", local_ability.link_ability);
2360         BP_LOG("   Link Partner Link Ability: 0x%x\n", lp_ability.link_ability);
2361
2362         status = txgbe_check_bp_ability(&local_ability, &lp_ability, hw);
2363
2364         wr32_epcs(hw, SR_AN_CTRL, 0);
2365         wr32_epcs(hw, VR_AN_KR_MODE_CL, 0);
2366
2367         /* 3.3. Check the FEC and KR Training for KR mode */
2368         BP_LOG("<3.3>. Check the FEC for KR mode ...\n");
2369         if ((local_ability.fec_ability & lp_ability.fec_ability) == 0x03) {
2370                 BP_LOG("Enable the Backplane KR FEC ...\n");
2371                 wr32_epcs(hw, SR_PMA_KR_FEC_CTRL, SR_PMA_KR_FEC_CTRL_EN);
2372         } else {
2373                 BP_LOG("Backplane KR FEC is disabled.\n");
2374         }
2375
2376         printf("Enter training.\n");
2377         /* CL72 KR training on */
2378         for (i = 0; i < 2; i++) {
2379                 /* 3.4. Check the CL72 KR Training for KR mode */
2380                 BP_LOG("<3.4>. Check the CL72 KR Training for KR mode ...\n");
2381                 BP_LOG("==================%d==================\n", i);
2382                 status = txgbe_enable_kr_training(hw);
2383                 BP_LOG("Check the Clause 72 KR Training status ...\n");
2384                 status |= txgbe_check_kr_training(hw);
2385
2386                 lp_reg = rd32_epcs(hw, SR_PMA_KR_LP_CESTS);
2387                 lp_reg &= SR_PMA_KR_LP_CESTS_RR;
2388                 BP_LOG("SR PMA MMD 10GBASE-KR LP Coefficient Status Register: 0x%x\n",
2389                         lp_reg);
2390                 ld_reg = rd32_epcs(hw, SR_PMA_KR_LD_CESTS);
2391                 ld_reg &= SR_PMA_KR_LD_CESTS_RR;
2392                 BP_LOG("SR PMA MMD 10GBASE-KR LD Coefficient Status Register: 0x%x\n",
2393                         ld_reg);
2394                 if (hw->devarg.poll == 0 && status != 0)
2395                         lp_reg = SR_PMA_KR_LP_CESTS_RR;
2396
2397                 if (lp_reg & ld_reg) {
2398                         BP_LOG("==================out==================\n");
2399                         status = txgbe_disable_kr_training(hw, 0, 0);
2400                         wr32_epcs(hw, SR_AN_CTRL, 0);
2401                         txgbe_clear_bp_intr(2, 0, hw);
2402                         txgbe_clear_bp_intr(1, 0, hw);
2403                         txgbe_clear_bp_intr(0, 0, hw);
2404                         for (i = 0; i < 10; i++) {
2405                                 value = rd32_epcs(hw, SR_XS_PCS_KR_STS1);
2406                                 if (value & SR_XS_PCS_KR_STS1_PLU) {
2407                                         BP_LOG("\nINT_AN_INT_CMPLT =1, AN73 Done Success.\n");
2408                                         wr32_epcs(hw, SR_AN_CTRL, 0);
2409                                         return 0;
2410                                 }
2411                                 msec_delay(10);
2412                         }
2413                         msec_delay(1000);
2414                         txgbe_set_link_to_kr(hw, 0);
2415
2416                         return 0;
2417                 }
2418
2419                 status |= txgbe_disable_kr_training(hw, 0, 0);
2420         }
2421
2422         txgbe_clear_bp_intr(2, 0, hw);
2423         txgbe_clear_bp_intr(1, 0, hw);
2424         txgbe_clear_bp_intr(0, 0, hw);
2425
2426         return status;
2427 }
2428
2429 /**
2430  * txgbe_get_bp_ability
2431  * @hw: pointer to hardware structure
2432  * @ability: pointer to blackplane ability structure
2433  * @link_partner:
2434  *      1: Get Link Partner Base Page
2435  *      2: Get Link Partner Next Page
2436  *              (only get NXP Ability Register 1 at the moment)
2437  *      0: Get Local Device Base Page
2438  */
2439 static void txgbe_get_bp_ability(struct txgbe_backplane_ability *ability,
2440                 u32 link_partner, struct txgbe_hw *hw)
2441 {
2442         u32 value = 0;
2443
2444         DEBUGFUNC("txgbe_get_bp_ability");
2445
2446         /* Link Partner Base Page */
2447         if (link_partner == 1) {
2448                 /* Read the link partner AN73 Base Page Ability Registers */
2449                 BP_LOG("Read the link partner AN73 Base Page Ability Registers...\n");
2450                 value = rd32_epcs(hw, SR_AN_MMD_LP_ABL1);
2451                 BP_LOG("SR AN MMD LP Base Page Ability Register 1: 0x%x\n",
2452                         value);
2453                 ability->next_page = SR_MMD_LP_ABL1_ADV_NP(value);
2454                 BP_LOG("  Next Page (bit15): %d\n", ability->next_page);
2455
2456                 value = rd32_epcs(hw, SR_AN_MMD_LP_ABL2);
2457                 BP_LOG("SR AN MMD LP Base Page Ability Register 2: 0x%x\n",
2458                         value);
2459                 ability->link_ability =
2460                         value & SR_AN_MMD_LP_ABL2_BP_TYPE_KR_KX4_KX;
2461                 BP_LOG("  Link Ability (bit[15:0]): 0x%x\n",
2462                         ability->link_ability);
2463                 BP_LOG("  (0x20- KX_ONLY, 0x40- KX4_ONLY, 0x60- KX4_KX\n");
2464                 BP_LOG("   0x80- KR_ONLY, 0xA0- KR_KX, 0xC0- KR_KX4, 0xE0- KR_KX4_KX)\n");
2465
2466                 value = rd32_epcs(hw, SR_AN_MMD_LP_ABL3);
2467                 BP_LOG("SR AN MMD LP Base Page Ability Register 3: 0x%x\n",
2468                         value);
2469                 BP_LOG("  FEC Request (bit15): %d\n", ((value >> 15) & 0x01));
2470                 BP_LOG("  FEC Enable  (bit14): %d\n", ((value >> 14) & 0x01));
2471                 ability->fec_ability = SR_AN_MMD_LP_ABL3_FCE(value);
2472         } else if (link_partner == 2) {
2473                 /* Read the link partner AN73 Next Page Ability Registers */
2474                 BP_LOG("\nRead the link partner AN73 Next Page Ability Registers...\n");
2475                 value = rd32_epcs(hw, SR_AN_LP_XNP_ABL1);
2476                 BP_LOG(" SR AN MMD LP XNP Ability Register 1: 0x%x\n", value);
2477                 ability->next_page = SR_AN_LP_XNP_ABL1_NP(value);
2478                 BP_LOG("  Next Page (bit15): %d\n", ability->next_page);
2479         } else {
2480                 /* Read the local AN73 Base Page Ability Registers */
2481                 BP_LOG("Read the local AN73 Base Page Ability Registers...\n");
2482                 value = rd32_epcs(hw, SR_AN_MMD_ADV_REG1);
2483                 BP_LOG("SR AN MMD Advertisement Register 1: 0x%x\n", value);
2484                 ability->next_page = SR_AN_MMD_ADV_REG1_NP(value);
2485                 BP_LOG("  Next Page (bit15): %d\n", ability->next_page);
2486
2487                 value = rd32_epcs(hw, SR_AN_MMD_ADV_REG2);
2488                 BP_LOG("SR AN MMD Advertisement Register 2: 0x%x\n", value);
2489                 ability->link_ability =
2490                         value & SR_AN_MMD_ADV_REG2_BP_TYPE_KR_KX4_KX;
2491                 BP_LOG("  Link Ability (bit[15:0]): 0x%x\n",
2492                         ability->link_ability);
2493                 BP_LOG("  (0x20- KX_ONLY, 0x40- KX4_ONLY, 0x60- KX4_KX\n");
2494                 BP_LOG("   0x80- KR_ONLY, 0xA0- KR_KX, 0xC0- KR_KX4, 0xE0- KR_KX4_KX)\n");
2495
2496                 value = rd32_epcs(hw, SR_AN_MMD_ADV_REG3);
2497                 BP_LOG("SR AN MMD Advertisement Register 3: 0x%x\n", value);
2498                 BP_LOG("  FEC Request (bit15): %d\n", ((value >> 15) & 0x01));
2499                 BP_LOG("  FEC Enable  (bit14): %d\n", ((value >> 14) & 0x01));
2500                 ability->fec_ability = SR_AN_MMD_ADV_REG3_FCE(value);
2501         }
2502
2503         BP_LOG("done.\n");
2504 }
2505
2506 /**
2507  * txgbe_check_bp_ability
2508  * @hw: pointer to hardware structure
2509  * @ability: pointer to blackplane ability structure
2510  */
2511 static s32 txgbe_check_bp_ability(struct txgbe_backplane_ability *local_ability,
2512         struct txgbe_backplane_ability *lp_ability, struct txgbe_hw *hw)
2513 {
2514         u32 com_link_abi;
2515         s32 ret = 0;
2516
2517         DEBUGFUNC("txgbe_check_bp_ability");
2518
2519         com_link_abi = local_ability->link_ability & lp_ability->link_ability;
2520         BP_LOG("com_link_abi = 0x%x, local_ability = 0x%x, lp_ability = 0x%x\n",
2521                 com_link_abi, local_ability->link_ability,
2522                 lp_ability->link_ability);
2523
2524         if (!com_link_abi) {
2525                 BP_LOG("The Link Partner does not support any compatible speed mode.\n");
2526                 ret = -1;
2527         } else if (com_link_abi & BP_TYPE_KR) {
2528                 if (local_ability->current_link_mode) {
2529                         BP_LOG("Link mode is not matched with Link Partner: [LINK_KR].\n");
2530                         BP_LOG("Set the local link mode to [LINK_KR] ...\n");
2531                         txgbe_set_link_to_kr(hw, 0);
2532                         ret = 1;
2533                 } else {
2534                         BP_LOG("Link mode is matched with Link Partner: [LINK_KR].\n");
2535                         ret = 0;
2536                 }
2537         } else if (com_link_abi & BP_TYPE_KX4) {
2538                 if (local_ability->current_link_mode == 0x10) {
2539                         BP_LOG("Link mode is matched with Link Partner: [LINK_KX4].\n");
2540                         ret = 0;
2541                 } else {
2542                         BP_LOG("Link mode is not matched with Link Partner: [LINK_KX4].\n");
2543                         BP_LOG("Set the local link mode to [LINK_KX4] ...\n");
2544                         txgbe_set_link_to_kx4(hw, 1);
2545                         ret = 1;
2546                 }
2547         } else if (com_link_abi & BP_TYPE_KX) {
2548                 if (local_ability->current_link_mode == 0x1) {
2549                         BP_LOG("Link mode is matched with Link Partner: [LINK_KX].\n");
2550                         ret = 0;
2551                 } else {
2552                         BP_LOG("Link mode is not matched with Link Partner: [LINK_KX].\n");
2553                         BP_LOG("Set the local link mode to [LINK_KX] ...\n");
2554                         txgbe_set_link_to_kx(hw, 1, 1);
2555                         ret = 1;
2556                 }
2557         }
2558
2559         return ret;
2560 }
2561
2562 /**
2563  * txgbe_clear_bp_intr
2564  * @hw: pointer to hardware structure
2565  * @index: the bit will be cleared
2566  * @index_high:
2567  *      index_high = 0: Only the index bit will be cleared
2568  *      index_high != 0: the [index_high, index] range will be cleared
2569  */
2570 static void txgbe_clear_bp_intr(u32 bit, u32 bit_high, struct txgbe_hw *hw)
2571 {
2572         u32 rdata = 0, wdata, i;
2573
2574         DEBUGFUNC("txgbe_clear_bp_intr");
2575
2576         rdata = rd32_epcs(hw, VR_AN_INTR);
2577         BP_LOG("[Before clear]Read VR AN MMD Interrupt Register: 0x%x\n",
2578                         rdata);
2579         BP_LOG("Interrupt: 0- AN_INT_CMPLT, 1-  AN_INC_LINK, 2- AN_PG_RCV\n\n");
2580
2581         wdata = rdata;
2582         if (bit_high) {
2583                 for (i = bit; i <= bit_high; i++)
2584                         wdata &= ~(1 << i);
2585         } else {
2586                 wdata &= ~(1 << bit);
2587         }
2588
2589         wr32_epcs(hw, VR_AN_INTR, wdata);
2590
2591         rdata = rd32_epcs(hw, VR_AN_INTR);
2592         BP_LOG("[After clear]Read VR AN MMD Interrupt Register: 0x%x\n", rdata);
2593 }
2594
2595 static s32 txgbe_enable_kr_training(struct txgbe_hw *hw)
2596 {
2597         s32 status = 0;
2598         u32 value = 0;
2599
2600         DEBUGFUNC("txgbe_enable_kr_training");
2601
2602         BP_LOG("Enable Clause 72 KR Training ...\n");
2603
2604         if (CL72_KRTR_PRBS_MODE_EN != 0xFFFF) {
2605                 /* Set PRBS Timer Duration Control to maximum 6.7ms in
2606                  * VR_PMA_KRTR_PRBS_CTRL2 Register
2607                  */
2608                 value = CL72_KRTR_PRBS_MODE_EN;
2609                 wr32_epcs(hw, VR_PMA_KRTR_PRBS_CTRL2, value);
2610                 /* Set PRBS Timer Duration Control to maximum 6.7ms in
2611                  * VR_PMA_KRTR_PRBS_CTRL1 Register
2612                  */
2613                 wr32_epcs(hw, VR_PMA_KRTR_PRBS_CTRL1,
2614                         VR_PMA_KRTR_PRBS_TIME_LMT);
2615                 /* Enable PRBS Mode to determine KR Training Status by setting
2616                  * Bit 0 of VR_PMA_KRTR_PRBS_CTRL0 Register
2617                  */
2618                 value = VR_PMA_KRTR_PRBS_MODE_EN;
2619         }
2620 #ifdef CL72_KRTR_PRBS31_EN
2621         /* Enable PRBS Mode to determine KR Training Status by setting
2622          * Bit 1 of VR_PMA_KRTR_PRBS_CTRL0 Register
2623          */
2624         value = VR_PMA_KRTR_PRBS31_EN;
2625 #endif
2626         wr32_epcs(hw, VR_PMA_KRTR_PRBS_CTRL0, value);
2627         /* Read PHY Lane0 TX EQ before Clause 72 KR Training. */
2628         txgbe_read_phy_lane_tx_eq(0, hw, 0, 0);
2629
2630         /* Enable the Clause 72 start-up protocol
2631          *   by setting Bit 1 of SR_PMA_KR_PMD_CTRL Register.
2632          * Restart the Clause 72 start-up protocol
2633          *   by setting Bit 0 of SR_PMA_KR_PMD_CTRL Register.
2634          */
2635         wr32_epcs(hw, SR_PMA_KR_PMD_CTRL,
2636                 SR_PMA_KR_PMD_CTRL_EN_TR | SR_PMA_KR_PMD_CTRL_RS_TR);
2637
2638         return status;
2639 }
2640
2641 static s32 txgbe_disable_kr_training(struct txgbe_hw *hw, s32 post, s32 mode)
2642 {
2643         s32 status = 0;
2644
2645         DEBUGFUNC("txgbe_disable_kr_training");
2646
2647         BP_LOG("Disable Clause 72 KR Training ...\n");
2648         /* Read PHY Lane0 TX EQ before Clause 72 KR Training. */
2649         txgbe_read_phy_lane_tx_eq(0, hw, post, mode);
2650
2651         wr32_epcs(hw, SR_PMA_KR_PMD_CTRL, SR_PMA_KR_PMD_CTRL_RS_TR);
2652
2653         return status;
2654 }
2655
2656 static s32 txgbe_check_kr_training(struct txgbe_hw *hw)
2657 {
2658         s32 status = 0;
2659         u32 value, test;
2660         int i;
2661         int times = hw->devarg.poll ? 35 : 20;
2662
2663         DEBUGFUNC("txgbe_check_kr_training");
2664
2665         for (i = 0; i < times; i++) {
2666                 value = rd32_epcs(hw, SR_PMA_KR_LP_CEU);
2667                 BP_LOG("SR PMA MMD 10GBASE-KR LP Coefficient Update Register: 0x%x\n",
2668                         value);
2669                 value = rd32_epcs(hw, SR_PMA_KR_LP_CESTS);
2670                 BP_LOG("SR PMA MMD 10GBASE-KR LP Coefficient Status Register: 0x%x\n",
2671                         value);
2672                 value = rd32_epcs(hw, SR_PMA_KR_LD_CEU);
2673                 BP_LOG("SR PMA MMD 10GBASE-KR LD Coefficient Update: 0x%x\n",
2674                         value);
2675                 value = rd32_epcs(hw, SR_PMA_KR_LD_CESTS);
2676                 BP_LOG("SR PMA MMD 10GBASE-KR LD Coefficient Status: 0x%x\n",
2677                         value);
2678                 value = rd32_epcs(hw, SR_PMA_KR_PMD_STS);
2679                 BP_LOG("SR PMA MMD 10GBASE-KR Status Register: 0x%x\n", value);
2680                 BP_LOG("  Training Failure         (bit3): %d\n",
2681                         ((value >> 3) & 0x01));
2682                 BP_LOG("  Start-Up Protocol Status (bit2): %d\n",
2683                         ((value >> 2) & 0x01));
2684                 BP_LOG("  Frame Lock               (bit1): %d\n",
2685                         ((value >> 1) & 0x01));
2686                 BP_LOG("  Receiver Status          (bit0): %d\n",
2687                         ((value >> 0) & 0x01));
2688
2689                 test = rd32_epcs(hw, SR_PMA_KR_LP_CESTS);
2690                 if (test & SR_PMA_KR_LP_CESTS_RR) {
2691                         BP_LOG("TEST Coefficient Status Register: 0x%x\n",
2692                                 test);
2693                         status = 1;
2694                 }
2695
2696                 if (value & SR_PMA_KR_PMD_STS_TR_FAIL) {
2697                         BP_LOG("Training is completed with failure.\n");
2698                         txgbe_read_phy_lane_tx_eq(0, hw, 0, 0);
2699                         return 0;
2700                 }
2701
2702                 if (value & SR_PMA_KR_PMD_STS_RCV) {
2703                         BP_LOG("Receiver trained and ready to receive data.\n");
2704                         txgbe_read_phy_lane_tx_eq(0, hw, 0, 0);
2705                         return 0;
2706                 }
2707
2708                 msec_delay(20);
2709         }
2710
2711         BP_LOG("ERROR: Check Clause 72 KR Training Complete Timeout.\n");
2712         return status;
2713 }
2714
2715 static void txgbe_read_phy_lane_tx_eq(u16 lane, struct txgbe_hw *hw,
2716                                 s32 post, s32 mode)
2717 {
2718         u32 value = 0;
2719         u32 addr;
2720         u32 tx_main_cursor, tx_pre_cursor, tx_post_cursor, lmain;
2721
2722         DEBUGFUNC("txgbe_read_phy_lane_tx_eq");
2723
2724         addr = TXGBE_PHY_LANE0_TX_EQ_CTL1 | (lane << 8);
2725         value = rd32_ephy(hw, addr);
2726         BP_LOG("PHY LANE TX EQ Read Value: %x\n", lane);
2727         tx_main_cursor = TXGBE_PHY_LANE0_TX_EQ_CTL1_MAIN(value);
2728         BP_LOG("TX_MAIN_CURSOR: %x\n", tx_main_cursor);
2729         UNREFERENCED_PARAMETER(tx_main_cursor);
2730
2731         addr = TXGBE_PHY_LANE0_TX_EQ_CTL2 | (lane << 8);
2732         value = rd32_ephy(hw, addr);
2733         tx_pre_cursor = value & TXGBE_PHY_LANE0_TX_EQ_CTL2_PRE;
2734         tx_post_cursor = TXGBE_PHY_LANE0_TX_EQ_CTL2_POST(value);
2735         BP_LOG("TX_PRE_CURSOR: %x\n", tx_pre_cursor);
2736         BP_LOG("TX_POST_CURSOR: %x\n", tx_post_cursor);
2737
2738         if (mode == 1) {
2739                 lmain = 160 - tx_pre_cursor - tx_post_cursor;
2740                 if (lmain < 88)
2741                         lmain = 88;
2742
2743                 if (post)
2744                         tx_post_cursor = post;
2745
2746                 wr32_epcs(hw, TXGBE_PHY_EQ_INIT_CTL1, tx_post_cursor);
2747                 wr32_epcs(hw, TXGBE_PHY_EQ_INIT_CTL0,
2748                                 tx_pre_cursor | (lmain << 8));
2749                 value = rd32_epcs(hw, TXGBE_PHY_TX_EQ_CTL1);
2750                 value &= ~TXGBE_PHY_TX_EQ_CTL1_DEF;
2751                 wr32_epcs(hw, TXGBE_PHY_TX_EQ_CTL1, value);
2752         }
2753 }