drivers/net/ixgbe/base/ixgbe_82598.c

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