drivers/net/ixgbe/base/ixgbe_82598.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2001-2018
   3  */
   4
   5 #include "ixgbe_type.h"
   6 #include "ixgbe_82598.h"
   7 #include "ixgbe_api.h"
   8 #include "ixgbe_common.h"
   9 #include "ixgbe_phy.h"
  10
  11 #define IXGBE_82598_MAX_TX_QUEUES 32
  12 #define IXGBE_82598_MAX_RX_QUEUES 64
  13 #define IXGBE_82598_RAR_ENTRIES   16
  14 #define IXGBE_82598_MC_TBL_SIZE  128
  15 #define IXGBE_82598_VFT_TBL_SIZE 128
  16 #define IXGBE_82598_RX_PB_SIZE   512
  17
  18 STATIC s32 ixgbe_get_link_capabilities_82598(struct ixgbe_hw *hw,
  19                                              ixgbe_link_speed *speed,
  20                                              bool *autoneg);
  21 STATIC enum ixgbe_media_type ixgbe_get_media_type_82598(struct ixgbe_hw *hw);
  22 STATIC s32 ixgbe_start_mac_link_82598(struct ixgbe_hw *hw,
  23                                       bool autoneg_wait_to_complete);
  24 STATIC s32 ixgbe_check_mac_link_82598(struct ixgbe_hw *hw,
  25                                       ixgbe_link_speed *speed, bool *link_up,
  26                                       bool link_up_wait_to_complete);
  27 STATIC s32 ixgbe_setup_mac_link_82598(struct ixgbe_hw *hw,
  28                                       ixgbe_link_speed speed,
  29                                       bool autoneg_wait_to_complete);
  30 STATIC s32 ixgbe_setup_copper_link_82598(struct ixgbe_hw *hw,
  31                                          ixgbe_link_speed speed,
  32                                          bool autoneg_wait_to_complete);
  33 STATIC s32 ixgbe_reset_hw_82598(struct ixgbe_hw *hw);
  34 STATIC s32 ixgbe_clear_vmdq_82598(struct ixgbe_hw *hw, u32 rar, u32 vmdq);
  35 STATIC s32 ixgbe_clear_vfta_82598(struct ixgbe_hw *hw);
  36 STATIC void ixgbe_set_rxpba_82598(struct ixgbe_hw *hw, int num_pb,
  37                                   u32 headroom, int strategy);
  38 STATIC s32 ixgbe_read_i2c_sff8472_82598(struct ixgbe_hw *hw, u8 byte_offset,
  39                                         u8 *sff8472_data);
  40 /**
  41  *  ixgbe_set_pcie_completion_timeout - set pci-e completion timeout
  42  *  @hw: pointer to the HW structure
  43  *
  44  *  The defaults for 82598 should be in the range of 50us to 50ms,
  45  *  however the hardware default for these parts is 500us to 1ms which is less
  46  *  than the 10ms recommended by the pci-e spec.  To address this we need to
  47  *  increase the value to either 10ms to 250ms for capability version 1 config,
  48  *  or 16ms to 55ms for version 2.
  49  **/
  50 void ixgbe_set_pcie_completion_timeout(struct ixgbe_hw *hw)
  51 {
  52         u32 gcr = IXGBE_READ_REG(hw, IXGBE_GCR);
  53         u16 pcie_devctl2;
  54
  55         /* only take action if timeout value is defaulted to 0 */
  56         if (gcr & IXGBE_GCR_CMPL_TMOUT_MASK)
  57                 goto out;
  58
  59         /*
  60          * if capababilities version is type 1 we can write the
  61          * timeout of 10ms to 250ms through the GCR register
  62          */
  63         if (!(gcr & IXGBE_GCR_CAP_VER2)) {
  64                 gcr |= IXGBE_GCR_CMPL_TMOUT_10ms;
  65                 goto out;
  66         }
  67
  68         /*
  69          * for version 2 capabilities we need to write the config space
  70          * directly in order to set the completion timeout value for
  71          * 16ms to 55ms
  72          */
  73         pcie_devctl2 = IXGBE_READ_PCIE_WORD(hw, IXGBE_PCI_DEVICE_CONTROL2);
  74         pcie_devctl2 |= IXGBE_PCI_DEVICE_CONTROL2_16ms;
  75         IXGBE_WRITE_PCIE_WORD(hw, IXGBE_PCI_DEVICE_CONTROL2, pcie_devctl2);
  76 out:
  77         /* disable completion timeout resend */
  78         gcr &= ~IXGBE_GCR_CMPL_TMOUT_RESEND;
  79         IXGBE_WRITE_REG(hw, IXGBE_GCR, gcr);
  80 }
  81
  82 /**
  83  *  ixgbe_init_ops_82598 - Inits func ptrs and MAC type
  84  *  @hw: pointer to hardware structure
  85  *
  86  *  Initialize the function pointers and assign the MAC type for 82598.
  87  *  Does not touch the hardware.
  88  **/
  89 s32 ixgbe_init_ops_82598(struct ixgbe_hw *hw)
  90 {
  91         struct ixgbe_mac_info *mac = &hw->mac;
  92         struct ixgbe_phy_info *phy = &hw->phy;
  93         s32 ret_val;
  94
  95         DEBUGFUNC("ixgbe_init_ops_82598");
  96
  97         ret_val = ixgbe_init_phy_ops_generic(hw);
  98         ret_val = ixgbe_init_ops_generic(hw);
  99
 100         /* PHY */
 101         phy->ops.init = ixgbe_init_phy_ops_82598;
 102
 103         /* MAC */
 104         mac->ops.start_hw = ixgbe_start_hw_82598;
 105         mac->ops.enable_relaxed_ordering = ixgbe_enable_relaxed_ordering_82598;
 106         mac->ops.reset_hw = ixgbe_reset_hw_82598;
 107         mac->ops.get_media_type = ixgbe_get_media_type_82598;
 108         mac->ops.get_supported_physical_layer =
 109                                 ixgbe_get_supported_physical_layer_82598;
 110         mac->ops.read_analog_reg8 = ixgbe_read_analog_reg8_82598;
 111         mac->ops.write_analog_reg8 = ixgbe_write_analog_reg8_82598;
 112         mac->ops.set_lan_id = ixgbe_set_lan_id_multi_port_pcie_82598;
 113         mac->ops.enable_rx_dma = ixgbe_enable_rx_dma_82598;
 114
 115         /* RAR, Multicast, VLAN */
 116         mac->ops.set_vmdq = ixgbe_set_vmdq_82598;
 117         mac->ops.clear_vmdq = ixgbe_clear_vmdq_82598;
 118         mac->ops.set_vfta = ixgbe_set_vfta_82598;
 119         mac->ops.set_vlvf = NULL;
 120         mac->ops.clear_vfta = ixgbe_clear_vfta_82598;
 121
 122         /* Flow Control */
 123         mac->ops.fc_enable = ixgbe_fc_enable_82598;
 124
 125         mac->mcft_size          = IXGBE_82598_MC_TBL_SIZE;
 126         mac->vft_size           = IXGBE_82598_VFT_TBL_SIZE;
 127         mac->num_rar_entries    = IXGBE_82598_RAR_ENTRIES;
 128         mac->rx_pb_size         = IXGBE_82598_RX_PB_SIZE;
 129         mac->max_rx_queues      = IXGBE_82598_MAX_RX_QUEUES;
 130         mac->max_tx_queues      = IXGBE_82598_MAX_TX_QUEUES;
 131         mac->max_msix_vectors   = ixgbe_get_pcie_msix_count_generic(hw);
 132
 133         /* SFP+ Module */
 134         phy->ops.read_i2c_eeprom = ixgbe_read_i2c_eeprom_82598;
 135         phy->ops.read_i2c_sff8472 = ixgbe_read_i2c_sff8472_82598;
 136
 137         /* Link */
 138         mac->ops.check_link = ixgbe_check_mac_link_82598;
 139         mac->ops.setup_link = ixgbe_setup_mac_link_82598;
 140         mac->ops.flap_tx_laser = NULL;
 141         mac->ops.get_link_capabilities = ixgbe_get_link_capabilities_82598;
 142         mac->ops.setup_rxpba = ixgbe_set_rxpba_82598;
 143
 144         /* Manageability interface */
 145         mac->ops.set_fw_drv_ver = NULL;
 146
 147         mac->ops.get_rtrup2tc = NULL;
 148
 149         return ret_val;
 150 }
 151
 152 /**
 153  *  ixgbe_init_phy_ops_82598 - PHY/SFP specific init
 154  *  @hw: pointer to hardware structure
 155  *
 156  *  Initialize any function pointers that were not able to be
 157  *  set during init_shared_code because the PHY/SFP type was
 158  *  not known.  Perform the SFP init if necessary.
 159  *
 160  **/
 161 s32 ixgbe_init_phy_ops_82598(struct ixgbe_hw *hw)
 162 {
 163         struct ixgbe_mac_info *mac = &hw->mac;
 164         struct ixgbe_phy_info *phy = &hw->phy;
 165         s32 ret_val = IXGBE_SUCCESS;
 166         u16 list_offset, data_offset;
 167
 168         DEBUGFUNC("ixgbe_init_phy_ops_82598");
 169
 170         /* Identify the PHY */
 171         phy->ops.identify(hw);
 172
 173         /* Overwrite the link function pointers if copper PHY */
 174         if (mac->ops.get_media_type(hw) == ixgbe_media_type_copper) {
 175                 mac->ops.setup_link = ixgbe_setup_copper_link_82598;
 176                 mac->ops.get_link_capabilities =
 177                                 ixgbe_get_copper_link_capabilities_generic;
 178         }
 179
 180         switch (hw->phy.type) {
 181         case ixgbe_phy_tn:
 182                 phy->ops.setup_link = ixgbe_setup_phy_link_tnx;
 183                 phy->ops.check_link = ixgbe_check_phy_link_tnx;
 184                 phy->ops.get_firmware_version =
 185                                         ixgbe_get_phy_firmware_version_tnx;
 186                 break;
 187         case ixgbe_phy_nl:
 188                 phy->ops.reset = ixgbe_reset_phy_nl;
 189
 190                 /* Call SFP+ identify routine to get the SFP+ module type */
 191                 ret_val = phy->ops.identify_sfp(hw);
 192                 if (ret_val != IXGBE_SUCCESS)
 193                         goto out;
 194                 else if (hw->phy.sfp_type == ixgbe_sfp_type_unknown) {
 195                         ret_val = IXGBE_ERR_SFP_NOT_SUPPORTED;
 196                         goto out;
 197                 }
 198
 199                 /* Check to see if SFP+ module is supported */
 200                 ret_val = ixgbe_get_sfp_init_sequence_offsets(hw,
 201                                                               &list_offset,
 202                                                               &data_offset);
 203                 if (ret_val != IXGBE_SUCCESS) {
 204                         ret_val = IXGBE_ERR_SFP_NOT_SUPPORTED;
 205                         goto out;
 206                 }
 207                 break;
 208         default:
 209                 break;
 210         }
 211
 212 out:
 213         return ret_val;
 214 }
 215
 216 /**
 217  *  ixgbe_start_hw_82598 - Prepare hardware for Tx/Rx
 218  *  @hw: pointer to hardware structure
 219  *
 220  *  Starts the hardware using the generic start_hw function.
 221  *  Disables relaxed ordering Then set pcie completion timeout
 222  *
 223  **/
 224 s32 ixgbe_start_hw_82598(struct ixgbe_hw *hw)
 225 {
 226         u32 regval;
 227         u32 i;
 228         s32 ret_val = IXGBE_SUCCESS;
 229
 230         DEBUGFUNC("ixgbe_start_hw_82598");
 231
 232         ret_val = ixgbe_start_hw_generic(hw);
 233         if (ret_val)
 234                 return ret_val;
 235
 236         /* Disable relaxed ordering */
 237         for (i = 0; ((i < hw->mac.max_tx_queues) &&
 238              (i < IXGBE_DCA_MAX_QUEUES_82598)); i++) {
 239                 regval = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL(i));
 240                 regval &= ~IXGBE_DCA_TXCTRL_DESC_WRO_EN;
 241                 IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL(i), regval);
 242         }
 243
 244         for (i = 0; ((i < hw->mac.max_rx_queues) &&
 245              (i < IXGBE_DCA_MAX_QUEUES_82598)); i++) {
 246                 regval = IXGBE_READ_REG(hw, IXGBE_DCA_RXCTRL(i));
 247                 regval &= ~(IXGBE_DCA_RXCTRL_DATA_WRO_EN |
 248                             IXGBE_DCA_RXCTRL_HEAD_WRO_EN);
 249                 IXGBE_WRITE_REG(hw, IXGBE_DCA_RXCTRL(i), regval);
 250         }
 251
 252         /* set the completion timeout for interface */
 253         ixgbe_set_pcie_completion_timeout(hw);
 254
 255         return ret_val;
 256 }
 257
 258 /**
 259  *  ixgbe_get_link_capabilities_82598 - Determines link capabilities
 260  *  @hw: pointer to hardware structure
 261  *  @speed: pointer to link speed
 262  *  @autoneg: boolean auto-negotiation value
 263  *
 264  *  Determines the link capabilities by reading the AUTOC register.
 265  **/
 266 STATIC s32 ixgbe_get_link_capabilities_82598(struct ixgbe_hw *hw,
 267                                              ixgbe_link_speed *speed,
 268                                              bool *autoneg)
 269 {
 270         s32 status = IXGBE_SUCCESS;
 271         u32 autoc = 0;
 272
 273         DEBUGFUNC("ixgbe_get_link_capabilities_82598");
 274
 275         /*
 276          * Determine link capabilities based on the stored value of AUTOC,
 277          * which represents EEPROM defaults.  If AUTOC value has not been
 278          * stored, use the current register value.
 279          */
 280         if (hw->mac.orig_link_settings_stored)
 281                 autoc = hw->mac.orig_autoc;
 282         else
 283                 autoc = IXGBE_READ_REG(hw, IXGBE_AUTOC);
 284
 285         switch (autoc & IXGBE_AUTOC_LMS_MASK) {
 286         case IXGBE_AUTOC_LMS_1G_LINK_NO_AN:
 287                 *speed = IXGBE_LINK_SPEED_1GB_FULL;
 288                 *autoneg = false;
 289                 break;
 290
 291         case IXGBE_AUTOC_LMS_10G_LINK_NO_AN:
 292                 *speed = IXGBE_LINK_SPEED_10GB_FULL;
 293                 *autoneg = false;
 294                 break;
 295
 296         case IXGBE_AUTOC_LMS_1G_AN:
 297                 *speed = IXGBE_LINK_SPEED_1GB_FULL;
 298                 *autoneg = true;
 299                 break;
 300
 301         case IXGBE_AUTOC_LMS_KX4_AN:
 302         case IXGBE_AUTOC_LMS_KX4_AN_1G_AN:
 303                 *speed = IXGBE_LINK_SPEED_UNKNOWN;
 304                 if (autoc & IXGBE_AUTOC_KX4_SUPP)
 305                         *speed |= IXGBE_LINK_SPEED_10GB_FULL;
 306                 if (autoc & IXGBE_AUTOC_KX_SUPP)
 307                         *speed |= IXGBE_LINK_SPEED_1GB_FULL;
 308                 *autoneg = true;
 309                 break;
 310
 311         default:
 312                 status = IXGBE_ERR_LINK_SETUP;
 313                 break;
 314         }
 315
 316         return status;
 317 }
 318
 319 /**
 320  *  ixgbe_get_media_type_82598 - Determines media type
 321  *  @hw: pointer to hardware structure
 322  *
 323  *  Returns the media type (fiber, copper, backplane)
 324  **/
 325 STATIC enum ixgbe_media_type ixgbe_get_media_type_82598(struct ixgbe_hw *hw)
 326 {
 327         enum ixgbe_media_type media_type;
 328
 329         DEBUGFUNC("ixgbe_get_media_type_82598");
 330
 331         /* Detect if there is a copper PHY attached. */
 332         switch (hw->phy.type) {
 333         case ixgbe_phy_cu_unknown:
 334         case ixgbe_phy_tn:
 335                 media_type = ixgbe_media_type_copper;
 336                 goto out;
 337         default:
 338                 break;
 339         }
 340
 341         /* Media type for I82598 is based on device ID */
 342         switch (hw->device_id) {
 343         case IXGBE_DEV_ID_82598:
 344         case IXGBE_DEV_ID_82598_BX:
 345                 /* Default device ID is mezzanine card KX/KX4 */
 346                 media_type = ixgbe_media_type_backplane;
 347                 break;
 348         case IXGBE_DEV_ID_82598AF_DUAL_PORT:
 349         case IXGBE_DEV_ID_82598AF_SINGLE_PORT:
 350         case IXGBE_DEV_ID_82598_DA_DUAL_PORT:
 351         case IXGBE_DEV_ID_82598_SR_DUAL_PORT_EM:
 352         case IXGBE_DEV_ID_82598EB_XF_LR:
 353         case IXGBE_DEV_ID_82598EB_SFP_LOM:
 354                 media_type = ixgbe_media_type_fiber;
 355                 break;
 356         case IXGBE_DEV_ID_82598EB_CX4:
 357         case IXGBE_DEV_ID_82598_CX4_DUAL_PORT:
 358                 media_type = ixgbe_media_type_cx4;
 359                 break;
 360         case IXGBE_DEV_ID_82598AT:
 361         case IXGBE_DEV_ID_82598AT2:
 362                 media_type = ixgbe_media_type_copper;
 363                 break;
 364         default:
 365                 media_type = ixgbe_media_type_unknown;
 366                 break;
 367         }
 368 out:
 369         return media_type;
 370 }
 371
 372 /**
 373  *  ixgbe_fc_enable_82598 - Enable flow control
 374  *  @hw: pointer to hardware structure
 375  *
 376  *  Enable flow control according to the current settings.
 377  **/
 378 s32 ixgbe_fc_enable_82598(struct ixgbe_hw *hw)
 379 {
 380         s32 ret_val = IXGBE_SUCCESS;
 381         u32 fctrl_reg;
 382         u32 rmcs_reg;
 383         u32 reg;
 384         u32 fcrtl, fcrth;
 385         u32 link_speed = 0;
 386         int i;
 387         bool link_up;
 388
 389         DEBUGFUNC("ixgbe_fc_enable_82598");
 390
 391         /* Validate the water mark configuration */
 392         if (!hw->fc.pause_time) {
 393                 ret_val = IXGBE_ERR_INVALID_LINK_SETTINGS;
 394                 goto out;
 395         }
 396
 397         /* Low water mark of zero causes XOFF floods */
 398         for (i = 0; i < IXGBE_DCB_MAX_TRAFFIC_CLASS; i++) {
 399                 if ((hw->fc.current_mode & ixgbe_fc_tx_pause) &&
 400                     hw->fc.high_water[i]) {
 401                         if (!hw->fc.low_water[i] ||
 402                             hw->fc.low_water[i] >= hw->fc.high_water[i]) {
 403                                 DEBUGOUT("Invalid water mark configuration\n");
 404                                 ret_val = IXGBE_ERR_INVALID_LINK_SETTINGS;
 405                                 goto out;
 406                         }
 407                 }
 408         }
 409
 410         /*
 411          * On 82598 having Rx FC on causes resets while doing 1G
 412          * so if it's on turn it off once we know link_speed. For
 413          * more details see 82598 Specification update.
 414          */
 415         hw->mac.ops.check_link(hw, &link_speed, &link_up, false);
 416         if (link_up && link_speed == IXGBE_LINK_SPEED_1GB_FULL) {
 417                 switch (hw->fc.requested_mode) {
 418                 case ixgbe_fc_full:
 419                         hw->fc.requested_mode = ixgbe_fc_tx_pause;
 420                         break;
 421                 case ixgbe_fc_rx_pause:
 422                         hw->fc.requested_mode = ixgbe_fc_none;
 423                         break;
 424                 default:
 425                         /* no change */
 426                         break;
 427                 }
 428         }
 429
 430         /* Negotiate the fc mode to use */
 431         ixgbe_fc_autoneg(hw);
 432
 433         /* Disable any previous flow control settings */
 434         fctrl_reg = IXGBE_READ_REG(hw, IXGBE_FCTRL);
 435         fctrl_reg &= ~(IXGBE_FCTRL_RFCE | IXGBE_FCTRL_RPFCE);
 436
 437         rmcs_reg = IXGBE_READ_REG(hw, IXGBE_RMCS);
 438         rmcs_reg &= ~(IXGBE_RMCS_TFCE_PRIORITY | IXGBE_RMCS_TFCE_802_3X);
 439
 440         /*
 441          * The possible values of fc.current_mode are:
 442          * 0: Flow control is completely disabled
 443          * 1: Rx flow control is enabled (we can receive pause frames,
 444          *    but not send pause frames).
 445          * 2: Tx flow control is enabled (we can send pause frames but
 446          *     we do not support receiving pause frames).
 447          * 3: Both Rx and Tx flow control (symmetric) are enabled.
 448          * other: Invalid.
 449          */
 450         switch (hw->fc.current_mode) {
 451         case ixgbe_fc_none:
 452                 /*
 453                  * Flow control is disabled by software override or autoneg.
 454                  * The code below will actually disable it in the HW.
 455                  */
 456                 break;
 457         case ixgbe_fc_rx_pause:
 458                 /*
 459                  * Rx Flow control is enabled and Tx Flow control is
 460                  * disabled by software override. Since there really
 461                  * isn't a way to advertise that we are capable of RX
 462                  * Pause ONLY, we will advertise that we support both
 463                  * symmetric and asymmetric Rx PAUSE.  Later, we will
 464                  * disable the adapter's ability to send PAUSE frames.
 465                  */
 466                 fctrl_reg |= IXGBE_FCTRL_RFCE;
 467                 break;
 468         case ixgbe_fc_tx_pause:
 469                 /*
 470                  * Tx Flow control is enabled, and Rx Flow control is
 471                  * disabled by software override.
 472                  */
 473                 rmcs_reg |= IXGBE_RMCS_TFCE_802_3X;
 474                 break;
 475         case ixgbe_fc_full:
 476                 /* Flow control (both Rx and Tx) is enabled by SW override. */
 477                 fctrl_reg |= IXGBE_FCTRL_RFCE;
 478                 rmcs_reg |= IXGBE_RMCS_TFCE_802_3X;
 479                 break;
 480         default:
 481                 DEBUGOUT("Flow control param set incorrectly\n");
 482                 ret_val = IXGBE_ERR_CONFIG;
 483                 goto out;
 484                 break;
 485         }
 486
 487         /* Set 802.3x based flow control settings. */
 488         fctrl_reg |= IXGBE_FCTRL_DPF;
 489         IXGBE_WRITE_REG(hw, IXGBE_FCTRL, fctrl_reg);
 490         IXGBE_WRITE_REG(hw, IXGBE_RMCS, rmcs_reg);
 491
 492         /* Set up and enable Rx high/low water mark thresholds, enable XON. */
 493         for (i = 0; i < IXGBE_DCB_MAX_TRAFFIC_CLASS; i++) {
 494                 if ((hw->fc.current_mode & ixgbe_fc_tx_pause) &&
 495                     hw->fc.high_water[i]) {
 496                         fcrtl = (hw->fc.low_water[i] << 10) | IXGBE_FCRTL_XONE;
 497                         fcrth = (hw->fc.high_water[i] << 10) | IXGBE_FCRTH_FCEN;
 498                         IXGBE_WRITE_REG(hw, IXGBE_FCRTL(i), fcrtl);
 499                         IXGBE_WRITE_REG(hw, IXGBE_FCRTH(i), fcrth);
 500                 } else {
 501                         IXGBE_WRITE_REG(hw, IXGBE_FCRTL(i), 0);
 502                         IXGBE_WRITE_REG(hw, IXGBE_FCRTH(i), 0);
 503                 }
 504
 505         }
 506
 507         /* Configure pause time (2 TCs per register) */
 508         reg = hw->fc.pause_time * 0x00010001;
 509         for (i = 0; i < (IXGBE_DCB_MAX_TRAFFIC_CLASS / 2); i++)
 510                 IXGBE_WRITE_REG(hw, IXGBE_FCTTV(i), reg);
 511
 512         /* Configure flow control refresh threshold value */
 513         IXGBE_WRITE_REG(hw, IXGBE_FCRTV, hw->fc.pause_time / 2);
 514
 515 out:
 516         return ret_val;
 517 }
 518
 519 /**
 520  *  ixgbe_start_mac_link_82598 - Configures MAC link settings
 521  *  @hw: pointer to hardware structure
 522  *  @autoneg_wait_to_complete: true when waiting for completion is needed
 523  *
 524  *  Configures link settings based on values in the ixgbe_hw struct.
 525  *  Restarts the link.  Performs autonegotiation if needed.
 526  **/
 527 STATIC s32 ixgbe_start_mac_link_82598(struct ixgbe_hw *hw,
 528                                       bool autoneg_wait_to_complete)
 529 {
 530         u32 autoc_reg;
 531         u32 links_reg;
 532         u32 i;
 533         s32 status = IXGBE_SUCCESS;
 534
 535         DEBUGFUNC("ixgbe_start_mac_link_82598");
 536
 537         /* Restart link */
 538         autoc_reg = IXGBE_READ_REG(hw, IXGBE_AUTOC);
 539         autoc_reg |= IXGBE_AUTOC_AN_RESTART;
 540         IXGBE_WRITE_REG(hw, IXGBE_AUTOC, autoc_reg);
 541
 542         /* Only poll for autoneg to complete if specified to do so */
 543         if (autoneg_wait_to_complete) {
 544                 if ((autoc_reg & IXGBE_AUTOC_LMS_MASK) ==
 545                      IXGBE_AUTOC_LMS_KX4_AN ||
 546                     (autoc_reg & IXGBE_AUTOC_LMS_MASK) ==
 547                      IXGBE_AUTOC_LMS_KX4_AN_1G_AN) {
 548                         links_reg = 0; /* Just in case Autoneg time = 0 */
 549                         for (i = 0; i < IXGBE_AUTO_NEG_TIME; i++) {
 550                                 links_reg = IXGBE_READ_REG(hw, IXGBE_LINKS);
 551                                 if (links_reg & IXGBE_LINKS_KX_AN_COMP)
 552                                         break;
 553                                 msec_delay(100);
 554                         }
 555                         if (!(links_reg & IXGBE_LINKS_KX_AN_COMP)) {
 556                                 status = IXGBE_ERR_AUTONEG_NOT_COMPLETE;
 557                                 DEBUGOUT("Autonegotiation did not complete.\n");
 558                         }
 559                 }
 560         }
 561
 562         /* Add delay to filter out noises during initial link setup */
 563         msec_delay(50);
 564
 565         return status;
 566 }
 567
 568 /**
 569  *  ixgbe_validate_link_ready - Function looks for phy link
 570  *  @hw: pointer to hardware structure
 571  *
 572  *  Function indicates success when phy link is available. If phy is not ready
 573  *  within 5 seconds of MAC indicating link, the function returns error.
 574  **/
 575 STATIC s32 ixgbe_validate_link_ready(struct ixgbe_hw *hw)
 576 {
 577         u32 timeout;
 578         u16 an_reg;
 579
 580         if (hw->device_id != IXGBE_DEV_ID_82598AT2)
 581                 return IXGBE_SUCCESS;
 582
 583         for (timeout = 0;
 584              timeout < IXGBE_VALIDATE_LINK_READY_TIMEOUT; timeout++) {
 585                 hw->phy.ops.read_reg(hw, IXGBE_MDIO_AUTO_NEG_STATUS,
 586                                      IXGBE_MDIO_AUTO_NEG_DEV_TYPE, &an_reg);
 587
 588                 if ((an_reg & IXGBE_MII_AUTONEG_COMPLETE) &&
 589                     (an_reg & IXGBE_MII_AUTONEG_LINK_UP))
 590                         break;
 591
 592                 msec_delay(100);
 593         }
 594
 595         if (timeout == IXGBE_VALIDATE_LINK_READY_TIMEOUT) {
 596                 DEBUGOUT("Link was indicated but link is down\n");
 597                 return IXGBE_ERR_LINK_SETUP;
 598         }
 599
 600         return IXGBE_SUCCESS;
 601 }
 602
 603 /**
 604  *  ixgbe_check_mac_link_82598 - Get link/speed status
 605  *  @hw: pointer to hardware structure
 606  *  @speed: pointer to link speed
 607  *  @link_up: true is link is up, false otherwise
 608  *  @link_up_wait_to_complete: bool used to wait for link up or not
 609  *
 610  *  Reads the links register to determine if link is up and the current speed
 611  **/
 612 STATIC s32 ixgbe_check_mac_link_82598(struct ixgbe_hw *hw,
 613                                       ixgbe_link_speed *speed, bool *link_up,
 614                                       bool link_up_wait_to_complete)
 615 {
 616         u32 links_reg;
 617         u32 i;
 618         u16 link_reg, adapt_comp_reg;
 619
 620         DEBUGFUNC("ixgbe_check_mac_link_82598");
 621
 622         /*
 623          * SERDES PHY requires us to read link status from undocumented
 624          * register 0xC79F.  Bit 0 set indicates link is up/ready; clear
 625          * indicates link down.  OxC00C is read to check that the XAUI lanes
 626          * are active.  Bit 0 clear indicates active; set indicates inactive.
 627          */
 628         if (hw->phy.type == ixgbe_phy_nl) {
 629                 hw->phy.ops.read_reg(hw, 0xC79F, IXGBE_TWINAX_DEV, &link_reg);
 630                 hw->phy.ops.read_reg(hw, 0xC79F, IXGBE_TWINAX_DEV, &link_reg);
 631                 hw->phy.ops.read_reg(hw, 0xC00C, IXGBE_TWINAX_DEV,
 632                                      &adapt_comp_reg);
 633                 if (link_up_wait_to_complete) {
 634                         for (i = 0; i < hw->mac.max_link_up_time; i++) {
 635                                 if ((link_reg & 1) &&
 636                                     ((adapt_comp_reg & 1) == 0)) {
 637                                         *link_up = true;
 638                                         break;
 639                                 } else {
 640                                         *link_up = false;
 641                                 }
 642                                 msec_delay(100);
 643                                 hw->phy.ops.read_reg(hw, 0xC79F,
 644                                                      IXGBE_TWINAX_DEV,
 645                                                      &link_reg);
 646                                 hw->phy.ops.read_reg(hw, 0xC00C,
 647                                                      IXGBE_TWINAX_DEV,
 648                                                      &adapt_comp_reg);
 649                         }
 650                 } else {
 651                         if ((link_reg & 1) && ((adapt_comp_reg & 1) == 0))
 652                                 *link_up = true;
 653                         else
 654                                 *link_up = false;
 655                 }
 656
 657                 if (*link_up == false)
 658                         goto out;
 659         }
 660
 661         links_reg = IXGBE_READ_REG(hw, IXGBE_LINKS);
 662         if (link_up_wait_to_complete) {
 663                 for (i = 0; i < hw->mac.max_link_up_time; i++) {
 664                         if (links_reg & IXGBE_LINKS_UP) {
 665                                 *link_up = true;
 666                                 break;
 667                         } else {
 668                                 *link_up = false;
 669                         }
 670                         msec_delay(100);
 671                         links_reg = IXGBE_READ_REG(hw, IXGBE_LINKS);
 672                 }
 673         } else {
 674                 if (links_reg & IXGBE_LINKS_UP)
 675                         *link_up = true;
 676                 else
 677                         *link_up = false;
 678         }
 679
 680         if (links_reg & IXGBE_LINKS_SPEED)
 681                 *speed = IXGBE_LINK_SPEED_10GB_FULL;
 682         else
 683                 *speed = IXGBE_LINK_SPEED_1GB_FULL;
 684
 685         if ((hw->device_id == IXGBE_DEV_ID_82598AT2) && (*link_up == true) &&
 686             (ixgbe_validate_link_ready(hw) != IXGBE_SUCCESS))
 687                 *link_up = false;
 688
 689 out:
 690         return IXGBE_SUCCESS;
 691 }
 692
 693 /**
 694  *  ixgbe_setup_mac_link_82598 - Set MAC link speed
 695  *  @hw: pointer to hardware structure
 696  *  @speed: new link speed
 697  *  @autoneg_wait_to_complete: true when waiting for completion is needed
 698  *
 699  *  Set the link speed in the AUTOC register and restarts link.
 700  **/
 701 STATIC s32 ixgbe_setup_mac_link_82598(struct ixgbe_hw *hw,
 702                                       ixgbe_link_speed speed,
 703                                       bool autoneg_wait_to_complete)
 704 {
 705         bool autoneg = false;
 706         s32 status = IXGBE_SUCCESS;
 707         ixgbe_link_speed link_capabilities = IXGBE_LINK_SPEED_UNKNOWN;
 708         u32 curr_autoc = IXGBE_READ_REG(hw, IXGBE_AUTOC);
 709         u32 autoc = curr_autoc;
 710         u32 link_mode = autoc & IXGBE_AUTOC_LMS_MASK;
 711
 712         DEBUGFUNC("ixgbe_setup_mac_link_82598");
 713
 714         /* Check to see if speed passed in is supported. */
 715         ixgbe_get_link_capabilities(hw, &link_capabilities, &autoneg);
 716         speed &= link_capabilities;
 717
 718         if (speed == IXGBE_LINK_SPEED_UNKNOWN)
 719                 status = IXGBE_ERR_LINK_SETUP;
 720
 721         /* Set KX4/KX support according to speed requested */
 722         else if (link_mode == IXGBE_AUTOC_LMS_KX4_AN ||
 723                  link_mode == IXGBE_AUTOC_LMS_KX4_AN_1G_AN) {
 724                 autoc &= ~IXGBE_AUTOC_KX4_KX_SUPP_MASK;
 725                 if (speed & IXGBE_LINK_SPEED_10GB_FULL)
 726                         autoc |= IXGBE_AUTOC_KX4_SUPP;
 727                 if (speed & IXGBE_LINK_SPEED_1GB_FULL)
 728                         autoc |= IXGBE_AUTOC_KX_SUPP;
 729                 if (autoc != curr_autoc)
 730                         IXGBE_WRITE_REG(hw, IXGBE_AUTOC, autoc);
 731         }
 732
 733         if (status == IXGBE_SUCCESS) {
 734                 /*
 735                  * Setup and restart the link based on the new values in
 736                  * ixgbe_hw This will write the AUTOC register based on the new
 737                  * stored values
 738                  */
 739                 status = ixgbe_start_mac_link_82598(hw,
 740                                                     autoneg_wait_to_complete);
 741         }
 742
 743         return status;
 744 }
 745
 746
 747 /**
 748  *  ixgbe_setup_copper_link_82598 - Set the PHY autoneg advertised field
 749  *  @hw: pointer to hardware structure
 750  *  @speed: new link speed
 751  *  @autoneg_wait_to_complete: true if waiting is needed to complete
 752  *
 753  *  Sets the link speed in the AUTOC register in the MAC and restarts link.
 754  **/
 755 STATIC s32 ixgbe_setup_copper_link_82598(struct ixgbe_hw *hw,
 756                                          ixgbe_link_speed speed,
 757                                          bool autoneg_wait_to_complete)
 758 {
 759         s32 status;
 760
 761         DEBUGFUNC("ixgbe_setup_copper_link_82598");
 762
 763         /* Setup the PHY according to input speed */
 764         status = hw->phy.ops.setup_link_speed(hw, speed,
 765                                               autoneg_wait_to_complete);
 766         /* Set up MAC */
 767         ixgbe_start_mac_link_82598(hw, autoneg_wait_to_complete);
 768
 769         return status;
 770 }
 771
 772 /**
 773  *  ixgbe_reset_hw_82598 - Performs hardware reset
 774  *  @hw: pointer to hardware structure
 775  *
 776  *  Resets the hardware by resetting the transmit and receive units, masks and
 777  *  clears all interrupts, performing a PHY reset, and performing a link (MAC)
 778  *  reset.
 779  **/
 780 STATIC s32 ixgbe_reset_hw_82598(struct ixgbe_hw *hw)
 781 {
 782         s32 status = IXGBE_SUCCESS;
 783         s32 phy_status = IXGBE_SUCCESS;
 784         u32 ctrl;
 785         u32 gheccr;
 786         u32 i;
 787         u32 autoc;
 788         u8  analog_val;
 789
 790         DEBUGFUNC("ixgbe_reset_hw_82598");
 791
 792         /* Call adapter stop to disable tx/rx and clear interrupts */
 793         status = hw->mac.ops.stop_adapter(hw);
 794         if (status != IXGBE_SUCCESS)
 795                 goto reset_hw_out;
 796
 797         /*
 798          * Power up the Atlas Tx lanes if they are currently powered down.
 799          * Atlas Tx lanes are powered down for MAC loopback tests, but
 800          * they are not automatically restored on reset.
 801          */
 802         hw->mac.ops.read_analog_reg8(hw, IXGBE_ATLAS_PDN_LPBK, &analog_val);
 803         if (analog_val & IXGBE_ATLAS_PDN_TX_REG_EN) {
 804                 /* Enable Tx Atlas so packets can be transmitted again */
 805                 hw->mac.ops.read_analog_reg8(hw, IXGBE_ATLAS_PDN_LPBK,
 806                                              &analog_val);
 807                 analog_val &= ~IXGBE_ATLAS_PDN_TX_REG_EN;
 808                 hw->mac.ops.write_analog_reg8(hw, IXGBE_ATLAS_PDN_LPBK,
 809                                               analog_val);
 810
 811                 hw->mac.ops.read_analog_reg8(hw, IXGBE_ATLAS_PDN_10G,
 812                                              &analog_val);
 813                 analog_val &= ~IXGBE_ATLAS_PDN_TX_10G_QL_ALL;
 814                 hw->mac.ops.write_analog_reg8(hw, IXGBE_ATLAS_PDN_10G,
 815                                               analog_val);
 816
 817                 hw->mac.ops.read_analog_reg8(hw, IXGBE_ATLAS_PDN_1G,
 818                                              &analog_val);
 819                 analog_val &= ~IXGBE_ATLAS_PDN_TX_1G_QL_ALL;
 820                 hw->mac.ops.write_analog_reg8(hw, IXGBE_ATLAS_PDN_1G,
 821                                               analog_val);
 822
 823                 hw->mac.ops.read_analog_reg8(hw, IXGBE_ATLAS_PDN_AN,
 824                                              &analog_val);
 825                 analog_val &= ~IXGBE_ATLAS_PDN_TX_AN_QL_ALL;
 826                 hw->mac.ops.write_analog_reg8(hw, IXGBE_ATLAS_PDN_AN,
 827                                               analog_val);
 828         }
 829
 830         /* Reset PHY */
 831         if (hw->phy.reset_disable == false) {
 832                 /* PHY ops must be identified and initialized prior to reset */
 833
 834                 /* Init PHY and function pointers, perform SFP setup */
 835                 phy_status = hw->phy.ops.init(hw);
 836                 if (phy_status == IXGBE_ERR_SFP_NOT_SUPPORTED)
 837                         goto reset_hw_out;
 838                 if (phy_status == IXGBE_ERR_SFP_NOT_PRESENT)
 839                         goto mac_reset_top;
 840
 841                 hw->phy.ops.reset(hw);
 842         }
 843
 844 mac_reset_top:
 845         /*
 846          * Issue global reset to the MAC.  This needs to be a SW reset.
 847          * If link reset is used, it might reset the MAC when mng is using it
 848          */
 849         ctrl = IXGBE_READ_REG(hw, IXGBE_CTRL) | IXGBE_CTRL_RST;
 850         IXGBE_WRITE_REG(hw, IXGBE_CTRL, ctrl);
 851         IXGBE_WRITE_FLUSH(hw);
 852
 853         /* Poll for reset bit to self-clear indicating reset is complete */
 854         for (i = 0; i < 10; i++) {
 855                 usec_delay(1);
 856                 ctrl = IXGBE_READ_REG(hw, IXGBE_CTRL);
 857                 if (!(ctrl & IXGBE_CTRL_RST))
 858                         break;
 859         }
 860         if (ctrl & IXGBE_CTRL_RST) {
 861                 status = IXGBE_ERR_RESET_FAILED;
 862                 DEBUGOUT("Reset polling failed to complete.\n");
 863         }
 864
 865         msec_delay(50);
 866
 867         /*
 868          * Double resets are required for recovery from certain error
 869          * conditions.  Between resets, it is necessary to stall to allow time
 870          * for any pending HW events to complete.
 871          */
 872         if (hw->mac.flags & IXGBE_FLAGS_DOUBLE_RESET_REQUIRED) {
 873                 hw->mac.flags &= ~IXGBE_FLAGS_DOUBLE_RESET_REQUIRED;
 874                 goto mac_reset_top;
 875         }
 876
 877         gheccr = IXGBE_READ_REG(hw, IXGBE_GHECCR);
 878         gheccr &= ~((1 << 21) | (1 << 18) | (1 << 9) | (1 << 6));
 879         IXGBE_WRITE_REG(hw, IXGBE_GHECCR, gheccr);
 880
 881         /*
 882          * Store the original AUTOC value if it has not been
 883          * stored off yet.  Otherwise restore the stored original
 884          * AUTOC value since the reset operation sets back to deaults.
 885          */
 886         autoc = IXGBE_READ_REG(hw, IXGBE_AUTOC);
 887         if (hw->mac.orig_link_settings_stored == false) {
 888                 hw->mac.orig_autoc = autoc;
 889                 hw->mac.orig_link_settings_stored = true;
 890         } else if (autoc != hw->mac.orig_autoc) {
 891                 IXGBE_WRITE_REG(hw, IXGBE_AUTOC, hw->mac.orig_autoc);
 892         }
 893
 894         /* Store the permanent mac address */
 895         hw->mac.ops.get_mac_addr(hw, hw->mac.perm_addr);
 896
 897         /*
 898          * Store MAC address from RAR0, clear receive address registers, and
 899          * clear the multicast table
 900          */
 901         hw->mac.ops.init_rx_addrs(hw);
 902
 903 reset_hw_out:
 904         if (phy_status != IXGBE_SUCCESS)
 905                 status = phy_status;
 906
 907         return status;
 908 }
 909
 910 /**
 911  *  ixgbe_set_vmdq_82598 - Associate a VMDq set index with a rx address
 912  *  @hw: pointer to hardware struct
 913  *  @rar: receive address register index to associate with a VMDq index
 914  *  @vmdq: VMDq set index
 915  **/
 916 s32 ixgbe_set_vmdq_82598(struct ixgbe_hw *hw, u32 rar, u32 vmdq)
 917 {
 918         u32 rar_high;
 919         u32 rar_entries = hw->mac.num_rar_entries;
 920
 921         DEBUGFUNC("ixgbe_set_vmdq_82598");
 922
 923         /* Make sure we are using a valid rar index range */
 924         if (rar >= rar_entries) {
 925                 DEBUGOUT1("RAR index %d is out of range.\n", rar);
 926                 return IXGBE_ERR_INVALID_ARGUMENT;
 927         }
 928
 929         rar_high = IXGBE_READ_REG(hw, IXGBE_RAH(rar));
 930         rar_high &= ~IXGBE_RAH_VIND_MASK;
 931         rar_high |= ((vmdq << IXGBE_RAH_VIND_SHIFT) & IXGBE_RAH_VIND_MASK);
 932         IXGBE_WRITE_REG(hw, IXGBE_RAH(rar), rar_high);
 933         return IXGBE_SUCCESS;
 934 }
 935
 936 /**
 937  *  ixgbe_clear_vmdq_82598 - Disassociate a VMDq set index from an rx address
 938  *  @hw: pointer to hardware struct
 939  *  @rar: receive address register index to associate with a VMDq index
 940  *  @vmdq: VMDq clear index (not used in 82598, but elsewhere)
 941  **/
 942 STATIC s32 ixgbe_clear_vmdq_82598(struct ixgbe_hw *hw, u32 rar, u32 vmdq)
 943 {
 944         u32 rar_high;
 945         u32 rar_entries = hw->mac.num_rar_entries;
 946
 947         UNREFERENCED_1PARAMETER(vmdq);
 948
 949         /* Make sure we are using a valid rar index range */
 950         if (rar >= rar_entries) {
 951                 DEBUGOUT1("RAR index %d is out of range.\n", rar);
 952                 return IXGBE_ERR_INVALID_ARGUMENT;
 953         }
 954
 955         rar_high = IXGBE_READ_REG(hw, IXGBE_RAH(rar));
 956         if (rar_high & IXGBE_RAH_VIND_MASK) {
 957                 rar_high &= ~IXGBE_RAH_VIND_MASK;
 958                 IXGBE_WRITE_REG(hw, IXGBE_RAH(rar), rar_high);
 959         }
 960
 961         return IXGBE_SUCCESS;
 962 }
 963
 964 /**
 965  *  ixgbe_set_vfta_82598 - Set VLAN filter table
 966  *  @hw: pointer to hardware structure
 967  *  @vlan: VLAN id to write to VLAN filter
 968  *  @vind: VMDq output index that maps queue to VLAN id in VFTA
 969  *  @vlan_on: boolean flag to turn on/off VLAN in VFTA
 970  *  @vlvf_bypass: boolean flag - unused
 971  *
 972  *  Turn on/off specified VLAN in the VLAN filter table.
 973  **/
 974 s32 ixgbe_set_vfta_82598(struct ixgbe_hw *hw, u32 vlan, u32 vind,
 975                          bool vlan_on, bool vlvf_bypass)
 976 {
 977         u32 regindex;
 978         u32 bitindex;
 979         u32 bits;
 980         u32 vftabyte;
 981
 982         UNREFERENCED_1PARAMETER(vlvf_bypass);
 983
 984         DEBUGFUNC("ixgbe_set_vfta_82598");
 985
 986         if (vlan > 4095)
 987                 return IXGBE_ERR_PARAM;
 988
 989         /* Determine 32-bit word position in array */
 990         regindex = (vlan >> 5) & 0x7F;   /* upper seven bits */
 991
 992         /* Determine the location of the (VMD) queue index */
 993         vftabyte =  ((vlan >> 3) & 0x03); /* bits (4:3) indicating byte array */
 994         bitindex = (vlan & 0x7) << 2;    /* lower 3 bits indicate nibble */
 995
 996         /* Set the nibble for VMD queue index */
 997         bits = IXGBE_READ_REG(hw, IXGBE_VFTAVIND(vftabyte, regindex));
 998         bits &= (~(0x0F << bitindex));
 999         bits |= (vind << bitindex);
1000         IXGBE_WRITE_REG(hw, IXGBE_VFTAVIND(vftabyte, regindex), bits);
1001
1002         /* Determine the location of the bit for this VLAN id */
1003         bitindex = vlan & 0x1F;   /* lower five bits */
1004
1005         bits = IXGBE_READ_REG(hw, IXGBE_VFTA(regindex));
1006         if (vlan_on)
1007                 /* Turn on this VLAN id */
1008                 bits |= (1 << bitindex);
1009         else
1010                 /* Turn off this VLAN id */
1011                 bits &= ~(1 << bitindex);
1012         IXGBE_WRITE_REG(hw, IXGBE_VFTA(regindex), bits);
1013
1014         return IXGBE_SUCCESS;
1015 }
1016
1017 /**
1018  *  ixgbe_clear_vfta_82598 - Clear VLAN filter table
1019  *  @hw: pointer to hardware structure
1020  *
1021  *  Clears the VLAN filer table, and the VMDq index associated with the filter
1022  **/
1023 STATIC s32 ixgbe_clear_vfta_82598(struct ixgbe_hw *hw)
1024 {
1025         u32 offset;
1026         u32 vlanbyte;
1027
1028         DEBUGFUNC("ixgbe_clear_vfta_82598");
1029
1030         for (offset = 0; offset < hw->mac.vft_size; offset++)
1031                 IXGBE_WRITE_REG(hw, IXGBE_VFTA(offset), 0);
1032
1033         for (vlanbyte = 0; vlanbyte < 4; vlanbyte++)
1034                 for (offset = 0; offset < hw->mac.vft_size; offset++)
1035                         IXGBE_WRITE_REG(hw, IXGBE_VFTAVIND(vlanbyte, offset),
1036                                         0);
1037
1038         return IXGBE_SUCCESS;
1039 }
1040
1041 /**
1042  *  ixgbe_read_analog_reg8_82598 - Reads 8 bit Atlas analog register
1043  *  @hw: pointer to hardware structure
1044  *  @reg: analog register to read
1045  *  @val: read value
1046  *
1047  *  Performs read operation to Atlas analog register specified.
1048  **/
1049 s32 ixgbe_read_analog_reg8_82598(struct ixgbe_hw *hw, u32 reg, u8 *val)
1050 {
1051         u32  atlas_ctl;
1052
1053         DEBUGFUNC("ixgbe_read_analog_reg8_82598");
1054
1055         IXGBE_WRITE_REG(hw, IXGBE_ATLASCTL,
1056                         IXGBE_ATLASCTL_WRITE_CMD | (reg << 8));
1057         IXGBE_WRITE_FLUSH(hw);
1058         usec_delay(10);
1059         atlas_ctl = IXGBE_READ_REG(hw, IXGBE_ATLASCTL);
1060         *val = (u8)atlas_ctl;
1061
1062         return IXGBE_SUCCESS;
1063 }
1064
1065 /**
1066  *  ixgbe_write_analog_reg8_82598 - Writes 8 bit Atlas analog register
1067  *  @hw: pointer to hardware structure
1068  *  @reg: atlas register to write
1069  *  @val: value to write
1070  *
1071  *  Performs write operation to Atlas analog register specified.
1072  **/
1073 s32 ixgbe_write_analog_reg8_82598(struct ixgbe_hw *hw, u32 reg, u8 val)
1074 {
1075         u32  atlas_ctl;
1076
1077         DEBUGFUNC("ixgbe_write_analog_reg8_82598");
1078
1079         atlas_ctl = (reg << 8) | val;
1080         IXGBE_WRITE_REG(hw, IXGBE_ATLASCTL, atlas_ctl);
1081         IXGBE_WRITE_FLUSH(hw);
1082         usec_delay(10);
1083
1084         return IXGBE_SUCCESS;
1085 }
1086
1087 /**
1088  *  ixgbe_read_i2c_phy_82598 - Reads 8 bit word over I2C interface.
1089  *  @hw: pointer to hardware structure
1090  *  @dev_addr: address to read from
1091  *  @byte_offset: byte offset to read from dev_addr
1092  *  @eeprom_data: value read
1093  *
1094  *  Performs 8 byte read operation to SFP module's EEPROM over I2C interface.
1095  **/
1096 STATIC s32 ixgbe_read_i2c_phy_82598(struct ixgbe_hw *hw, u8 dev_addr,
1097                                     u8 byte_offset, u8 *eeprom_data)
1098 {
1099         s32 status = IXGBE_SUCCESS;
1100         u16 sfp_addr = 0;
1101         u16 sfp_data = 0;
1102         u16 sfp_stat = 0;
1103         u16 gssr;
1104         u32 i;
1105
1106         DEBUGFUNC("ixgbe_read_i2c_phy_82598");
1107
1108         if (IXGBE_READ_REG(hw, IXGBE_STATUS) & IXGBE_STATUS_LAN_ID_1)
1109                 gssr = IXGBE_GSSR_PHY1_SM;
1110         else
1111                 gssr = IXGBE_GSSR_PHY0_SM;
1112
1113         if (hw->mac.ops.acquire_swfw_sync(hw, gssr) != IXGBE_SUCCESS)
1114                 return IXGBE_ERR_SWFW_SYNC;
1115
1116         if (hw->phy.type == ixgbe_phy_nl) {
1117                 /*
1118                  * NetLogic phy SDA/SCL registers are at addresses 0xC30A to
1119                  * 0xC30D. These registers are used to talk to the SFP+
1120                  * module's EEPROM through the SDA/SCL (I2C) interface.
1121                  */
1122                 sfp_addr = (dev_addr << 8) + byte_offset;
1123                 sfp_addr = (sfp_addr | IXGBE_I2C_EEPROM_READ_MASK);
1124                 hw->phy.ops.write_reg_mdi(hw,
1125                                           IXGBE_MDIO_PMA_PMD_SDA_SCL_ADDR,
1126                                           IXGBE_MDIO_PMA_PMD_DEV_TYPE,
1127                                           sfp_addr);
1128
1129                 /* Poll status */
1130                 for (i = 0; i < 100; i++) {
1131                         hw->phy.ops.read_reg_mdi(hw,
1132                                                 IXGBE_MDIO_PMA_PMD_SDA_SCL_STAT,
1133                                                 IXGBE_MDIO_PMA_PMD_DEV_TYPE,
1134                                                 &sfp_stat);
1135                         sfp_stat = sfp_stat & IXGBE_I2C_EEPROM_STATUS_MASK;
1136                         if (sfp_stat != IXGBE_I2C_EEPROM_STATUS_IN_PROGRESS)
1137                                 break;
1138                         msec_delay(10);
1139                 }
1140
1141                 if (sfp_stat != IXGBE_I2C_EEPROM_STATUS_PASS) {
1142                         DEBUGOUT("EEPROM read did not pass.\n");
1143                         status = IXGBE_ERR_SFP_NOT_PRESENT;
1144                         goto out;
1145                 }
1146
1147                 /* Read data */
1148                 hw->phy.ops.read_reg_mdi(hw, IXGBE_MDIO_PMA_PMD_SDA_SCL_DATA,
1149                                         IXGBE_MDIO_PMA_PMD_DEV_TYPE, &sfp_data);
1150
1151                 *eeprom_data = (u8)(sfp_data >> 8);
1152         } else {
1153                 status = IXGBE_ERR_PHY;
1154         }
1155
1156 out:
1157         hw->mac.ops.release_swfw_sync(hw, gssr);
1158         return status;
1159 }
1160
1161 /**
1162  *  ixgbe_read_i2c_eeprom_82598 - Reads 8 bit word over I2C interface.
1163  *  @hw: pointer to hardware structure
1164  *  @byte_offset: EEPROM byte offset to read
1165  *  @eeprom_data: value read
1166  *
1167  *  Performs 8 byte read operation to SFP module's EEPROM over I2C interface.
1168  **/
1169 s32 ixgbe_read_i2c_eeprom_82598(struct ixgbe_hw *hw, u8 byte_offset,
1170                                 u8 *eeprom_data)
1171 {
1172         return ixgbe_read_i2c_phy_82598(hw, IXGBE_I2C_EEPROM_DEV_ADDR,
1173                                         byte_offset, eeprom_data);
1174 }
1175
1176 /**
1177  *  ixgbe_read_i2c_sff8472_82598 - Reads 8 bit word over I2C interface.
1178  *  @hw: pointer to hardware structure
1179  *  @byte_offset: byte offset at address 0xA2
1180  *  @sff8472_data: value read
1181  *
1182  *  Performs 8 byte read operation to SFP module's SFF-8472 data over I2C
1183  **/
1184 STATIC s32 ixgbe_read_i2c_sff8472_82598(struct ixgbe_hw *hw, u8 byte_offset,
1185                                         u8 *sff8472_data)
1186 {
1187         return ixgbe_read_i2c_phy_82598(hw, IXGBE_I2C_EEPROM_DEV_ADDR2,
1188                                         byte_offset, sff8472_data);
1189 }
1190
1191 /**
1192  *  ixgbe_get_supported_physical_layer_82598 - Returns physical layer type
1193  *  @hw: pointer to hardware structure
1194  *
1195  *  Determines physical layer capabilities of the current configuration.
1196  **/
1197 u64 ixgbe_get_supported_physical_layer_82598(struct ixgbe_hw *hw)
1198 {
1199         u64 physical_layer = IXGBE_PHYSICAL_LAYER_UNKNOWN;
1200         u32 autoc = IXGBE_READ_REG(hw, IXGBE_AUTOC);
1201         u32 pma_pmd_10g = autoc & IXGBE_AUTOC_10G_PMA_PMD_MASK;
1202         u32 pma_pmd_1g = autoc & IXGBE_AUTOC_1G_PMA_PMD_MASK;
1203         u16 ext_ability = 0;
1204
1205         DEBUGFUNC("ixgbe_get_supported_physical_layer_82598");
1206
1207         hw->phy.ops.identify(hw);
1208
1209         /* Copper PHY must be checked before AUTOC LMS to determine correct
1210          * physical layer because 10GBase-T PHYs use LMS = KX4/KX */
1211         switch (hw->phy.type) {
1212         case ixgbe_phy_tn:
1213         case ixgbe_phy_cu_unknown:
1214                 hw->phy.ops.read_reg(hw, IXGBE_MDIO_PHY_EXT_ABILITY,
1215                 IXGBE_MDIO_PMA_PMD_DEV_TYPE, &ext_ability);
1216                 if (ext_ability & IXGBE_MDIO_PHY_10GBASET_ABILITY)
1217                         physical_layer |= IXGBE_PHYSICAL_LAYER_10GBASE_T;
1218                 if (ext_ability & IXGBE_MDIO_PHY_1000BASET_ABILITY)
1219                         physical_layer |= IXGBE_PHYSICAL_LAYER_1000BASE_T;
1220                 if (ext_ability & IXGBE_MDIO_PHY_100BASETX_ABILITY)
1221                         physical_layer |= IXGBE_PHYSICAL_LAYER_100BASE_TX;
1222                 goto out;
1223         default:
1224                 break;
1225         }
1226
1227         switch (autoc & IXGBE_AUTOC_LMS_MASK) {
1228         case IXGBE_AUTOC_LMS_1G_AN:
1229         case IXGBE_AUTOC_LMS_1G_LINK_NO_AN:
1230                 if (pma_pmd_1g == IXGBE_AUTOC_1G_KX)
1231                         physical_layer = IXGBE_PHYSICAL_LAYER_1000BASE_KX;
1232                 else
1233                         physical_layer = IXGBE_PHYSICAL_LAYER_1000BASE_BX;
1234                 break;
1235         case IXGBE_AUTOC_LMS_10G_LINK_NO_AN:
1236                 if (pma_pmd_10g == IXGBE_AUTOC_10G_CX4)
1237                         physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_CX4;
1238                 else if (pma_pmd_10g == IXGBE_AUTOC_10G_KX4)
1239                         physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_KX4;
1240                 else /* XAUI */
1241                         physical_layer = IXGBE_PHYSICAL_LAYER_UNKNOWN;
1242                 break;
1243         case IXGBE_AUTOC_LMS_KX4_AN:
1244         case IXGBE_AUTOC_LMS_KX4_AN_1G_AN:
1245                 if (autoc & IXGBE_AUTOC_KX_SUPP)
1246                         physical_layer |= IXGBE_PHYSICAL_LAYER_1000BASE_KX;
1247                 if (autoc & IXGBE_AUTOC_KX4_SUPP)
1248                         physical_layer |= IXGBE_PHYSICAL_LAYER_10GBASE_KX4;
1249                 break;
1250         default:
1251                 break;
1252         }
1253
1254         if (hw->phy.type == ixgbe_phy_nl) {
1255                 hw->phy.ops.identify_sfp(hw);
1256
1257                 switch (hw->phy.sfp_type) {
1258                 case ixgbe_sfp_type_da_cu:
1259                         physical_layer = IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU;
1260                         break;
1261                 case ixgbe_sfp_type_sr:
1262                         physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_SR;
1263                         break;
1264                 case ixgbe_sfp_type_lr:
1265                         physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_LR;
1266                         break;
1267                 default:
1268                         physical_layer = IXGBE_PHYSICAL_LAYER_UNKNOWN;
1269                         break;
1270                 }
1271         }
1272
1273         switch (hw->device_id) {
1274         case IXGBE_DEV_ID_82598_DA_DUAL_PORT:
1275                 physical_layer = IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU;
1276                 break;
1277         case IXGBE_DEV_ID_82598AF_DUAL_PORT:
1278         case IXGBE_DEV_ID_82598AF_SINGLE_PORT:
1279         case IXGBE_DEV_ID_82598_SR_DUAL_PORT_EM:
1280                 physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_SR;
1281                 break;
1282         case IXGBE_DEV_ID_82598EB_XF_LR:
1283                 physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_LR;
1284                 break;
1285         default:
1286                 break;
1287         }
1288
1289 out:
1290         return physical_layer;
1291 }
1292
1293 /**
1294  *  ixgbe_set_lan_id_multi_port_pcie_82598 - Set LAN id for PCIe multiple
1295  *  port devices.
1296  *  @hw: pointer to the HW structure
1297  *
1298  *  Calls common function and corrects issue with some single port devices
1299  *  that enable LAN1 but not LAN0.
1300  **/
1301 void ixgbe_set_lan_id_multi_port_pcie_82598(struct ixgbe_hw *hw)
1302 {
1303         struct ixgbe_bus_info *bus = &hw->bus;
1304         u16 pci_gen = 0;
1305         u16 pci_ctrl2 = 0;
1306
1307         DEBUGFUNC("ixgbe_set_lan_id_multi_port_pcie_82598");
1308
1309         ixgbe_set_lan_id_multi_port_pcie(hw);
1310
1311         /* check if LAN0 is disabled */
1312         hw->eeprom.ops.read(hw, IXGBE_PCIE_GENERAL_PTR, &pci_gen);
1313         if ((pci_gen != 0) && (pci_gen != 0xFFFF)) {
1314
1315                 hw->eeprom.ops.read(hw, pci_gen + IXGBE_PCIE_CTRL2, &pci_ctrl2);
1316
1317                 /* if LAN0 is completely disabled force function to 0 */
1318                 if ((pci_ctrl2 & IXGBE_PCIE_CTRL2_LAN_DISABLE) &&
1319                     !(pci_ctrl2 & IXGBE_PCIE_CTRL2_DISABLE_SELECT) &&
1320                     !(pci_ctrl2 & IXGBE_PCIE_CTRL2_DUMMY_ENABLE)) {
1321
1322                         bus->func = 0;
1323                 }
1324         }
1325 }
1326
1327 /**
1328  *  ixgbe_enable_relaxed_ordering_82598 - enable relaxed ordering
1329  *  @hw: pointer to hardware structure
1330  *
1331  **/
1332 void ixgbe_enable_relaxed_ordering_82598(struct ixgbe_hw *hw)
1333 {
1334         u32 regval;
1335         u32 i;
1336
1337         DEBUGFUNC("ixgbe_enable_relaxed_ordering_82598");
1338
1339         /* Enable relaxed ordering */
1340         for (i = 0; ((i < hw->mac.max_tx_queues) &&
1341              (i < IXGBE_DCA_MAX_QUEUES_82598)); i++) {
1342                 regval = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL(i));
1343                 regval |= IXGBE_DCA_TXCTRL_DESC_WRO_EN;
1344                 IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL(i), regval);
1345         }
1346
1347         for (i = 0; ((i < hw->mac.max_rx_queues) &&
1348              (i < IXGBE_DCA_MAX_QUEUES_82598)); i++) {
1349                 regval = IXGBE_READ_REG(hw, IXGBE_DCA_RXCTRL(i));
1350                 regval |= IXGBE_DCA_RXCTRL_DATA_WRO_EN |
1351                           IXGBE_DCA_RXCTRL_HEAD_WRO_EN;
1352                 IXGBE_WRITE_REG(hw, IXGBE_DCA_RXCTRL(i), regval);
1353         }
1354
1355 }
1356
1357 /**
1358  * ixgbe_set_rxpba_82598 - Initialize RX packet buffer
1359  * @hw: pointer to hardware structure
1360  * @num_pb: number of packet buffers to allocate
1361  * @headroom: reserve n KB of headroom
1362  * @strategy: packet buffer allocation strategy
1363  **/
1364 STATIC void ixgbe_set_rxpba_82598(struct ixgbe_hw *hw, int num_pb,
1365                                   u32 headroom, int strategy)
1366 {
1367         u32 rxpktsize = IXGBE_RXPBSIZE_64KB;
1368         u8 i = 0;
1369         UNREFERENCED_1PARAMETER(headroom);
1370
1371         if (!num_pb)
1372                 return;
1373
1374         /* Setup Rx packet buffer sizes */
1375         switch (strategy) {
1376         case PBA_STRATEGY_WEIGHTED:
1377                 /* Setup the first four at 80KB */
1378                 rxpktsize = IXGBE_RXPBSIZE_80KB;
1379                 for (; i < 4; i++)
1380                         IXGBE_WRITE_REG(hw, IXGBE_RXPBSIZE(i), rxpktsize);
1381                 /* Setup the last four at 48KB...don't re-init i */
1382                 rxpktsize = IXGBE_RXPBSIZE_48KB;
1383                 /* Fall Through */
1384         case PBA_STRATEGY_EQUAL:
1385         default:
1386                 /* Divide the remaining Rx packet buffer evenly among the TCs */
1387                 for (; i < IXGBE_MAX_PACKET_BUFFERS; i++)
1388                         IXGBE_WRITE_REG(hw, IXGBE_RXPBSIZE(i), rxpktsize);
1389                 break;
1390         }
1391
1392         /* Setup Tx packet buffer sizes */
1393         for (i = 0; i < IXGBE_MAX_PACKET_BUFFERS; i++)
1394                 IXGBE_WRITE_REG(hw, IXGBE_TXPBSIZE(i), IXGBE_TXPBSIZE_40KB);
1395 }
1396
1397 /**
1398  *  ixgbe_enable_rx_dma_82598 - Enable the Rx DMA unit
1399  *  @hw: pointer to hardware structure
1400  *  @regval: register value to write to RXCTRL
1401  *
1402  *  Enables the Rx DMA unit
1403  **/
1404 s32 ixgbe_enable_rx_dma_82598(struct ixgbe_hw *hw, u32 regval)
1405 {
1406         DEBUGFUNC("ixgbe_enable_rx_dma_82598");
1407
1408         IXGBE_WRITE_REG(hw, IXGBE_RXCTRL, regval);
1409
1410         return IXGBE_SUCCESS;
1411 }