lib/librte_pmd_ixgbe/ixgbe/ixgbe_82598.c

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