lib/librte_pmd_ixgbe/ixgbe/ixgbe_82599.c

   1 /*******************************************************************************
   2
   3 Copyright (c) 2001-2014, 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_82599.h"
  36 #include "ixgbe_api.h"
  37 #include "ixgbe_common.h"
  38 #include "ixgbe_phy.h"
  39 #ident "$Id: ixgbe_82599.c,v 1.334 2013/12/04 22:34:00 jtkirshe Exp $"
  40
  41 #define IXGBE_82599_MAX_TX_QUEUES 128
  42 #define IXGBE_82599_MAX_RX_QUEUES 128
  43 #define IXGBE_82599_RAR_ENTRIES   128
  44 #define IXGBE_82599_MC_TBL_SIZE   128
  45 #define IXGBE_82599_VFT_TBL_SIZE  128
  46 #define IXGBE_82599_RX_PB_SIZE    512
  47
  48 STATIC s32 ixgbe_setup_copper_link_82599(struct ixgbe_hw *hw,
  49                                          ixgbe_link_speed speed,
  50                                          bool autoneg_wait_to_complete);
  51 STATIC s32 ixgbe_verify_fw_version_82599(struct ixgbe_hw *hw);
  52 STATIC s32 ixgbe_read_eeprom_82599(struct ixgbe_hw *hw,
  53                                    u16 offset, u16 *data);
  54 STATIC s32 ixgbe_read_eeprom_buffer_82599(struct ixgbe_hw *hw, u16 offset,
  55                                           u16 words, u16 *data);
  56 STATIC s32 ixgbe_read_i2c_byte_82599(struct ixgbe_hw *hw, u8 byte_offset,
  57                                         u8 dev_addr, u8 *data);
  58 STATIC s32 ixgbe_write_i2c_byte_82599(struct ixgbe_hw *hw, u8 byte_offset,
  59                                         u8 dev_addr, u8 data);
  60
  61 void ixgbe_init_mac_link_ops_82599(struct ixgbe_hw *hw)
  62 {
  63         struct ixgbe_mac_info *mac = &hw->mac;
  64
  65         DEBUGFUNC("ixgbe_init_mac_link_ops_82599");
  66
  67         /*
  68          * enable the laser control functions for SFP+ fiber
  69          * and MNG not enabled
  70          */
  71         if ((mac->ops.get_media_type(hw) == ixgbe_media_type_fiber) &&
  72             !ixgbe_mng_enabled(hw)) {
  73                 mac->ops.disable_tx_laser =
  74                                        &ixgbe_disable_tx_laser_multispeed_fiber;
  75                 mac->ops.enable_tx_laser =
  76                                         &ixgbe_enable_tx_laser_multispeed_fiber;
  77                 mac->ops.flap_tx_laser = &ixgbe_flap_tx_laser_multispeed_fiber;
  78
  79         } else {
  80                 mac->ops.disable_tx_laser = NULL;
  81                 mac->ops.enable_tx_laser = NULL;
  82                 mac->ops.flap_tx_laser = NULL;
  83         }
  84
  85         if (hw->phy.multispeed_fiber) {
  86                 /* Set up dual speed SFP+ support */
  87                 mac->ops.setup_link = &ixgbe_setup_mac_link_multispeed_fiber;
  88         } else {
  89                 if ((ixgbe_get_media_type(hw) == ixgbe_media_type_backplane) &&
  90                      (hw->phy.smart_speed == ixgbe_smart_speed_auto ||
  91                       hw->phy.smart_speed == ixgbe_smart_speed_on) &&
  92                       !ixgbe_verify_lesm_fw_enabled_82599(hw)) {
  93                         mac->ops.setup_link = &ixgbe_setup_mac_link_smartspeed;
  94                 } else {
  95                         mac->ops.setup_link = &ixgbe_setup_mac_link_82599;
  96                 }
  97         }
  98 }
  99
 100 /**
 101  *  ixgbe_init_phy_ops_82599 - PHY/SFP specific init
 102  *  @hw: pointer to hardware structure
 103  *
 104  *  Initialize any function pointers that were not able to be
 105  *  set during init_shared_code because the PHY/SFP type was
 106  *  not known.  Perform the SFP init if necessary.
 107  *
 108  **/
 109 s32 ixgbe_init_phy_ops_82599(struct ixgbe_hw *hw)
 110 {
 111         struct ixgbe_mac_info *mac = &hw->mac;
 112         struct ixgbe_phy_info *phy = &hw->phy;
 113         s32 ret_val = IXGBE_SUCCESS;
 114         u32 esdp;
 115
 116         DEBUGFUNC("ixgbe_init_phy_ops_82599");
 117
 118         if (hw->device_id == IXGBE_DEV_ID_82599_QSFP_SF_QP) {
 119                 /* Store flag indicating I2C bus access control unit. */
 120                 hw->phy.qsfp_shared_i2c_bus = TRUE;
 121
 122                 /* Initialize access to QSFP+ I2C bus */
 123                 esdp = IXGBE_READ_REG(hw, IXGBE_ESDP);
 124                 esdp |= IXGBE_ESDP_SDP0_DIR;
 125                 esdp &= ~IXGBE_ESDP_SDP1_DIR;
 126                 esdp &= ~IXGBE_ESDP_SDP0;
 127                 esdp &= ~IXGBE_ESDP_SDP0_NATIVE;
 128                 esdp &= ~IXGBE_ESDP_SDP1_NATIVE;
 129                 IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp);
 130                 IXGBE_WRITE_FLUSH(hw);
 131
 132                 phy->ops.read_i2c_byte = &ixgbe_read_i2c_byte_82599;
 133                 phy->ops.write_i2c_byte = &ixgbe_write_i2c_byte_82599;
 134         }
 135         /* Identify the PHY or SFP module */
 136         ret_val = phy->ops.identify(hw);
 137         if (ret_val == IXGBE_ERR_SFP_NOT_SUPPORTED)
 138                 goto init_phy_ops_out;
 139
 140         /* Setup function pointers based on detected SFP module and speeds */
 141         ixgbe_init_mac_link_ops_82599(hw);
 142         if (hw->phy.sfp_type != ixgbe_sfp_type_unknown)
 143                 hw->phy.ops.reset = NULL;
 144
 145         /* If copper media, overwrite with copper function pointers */
 146         if (mac->ops.get_media_type(hw) == ixgbe_media_type_copper) {
 147                 mac->ops.setup_link = &ixgbe_setup_copper_link_82599;
 148                 mac->ops.get_link_capabilities =
 149                                   &ixgbe_get_copper_link_capabilities_generic;
 150         }
 151
 152         /* Set necessary function pointers based on PHY type */
 153         switch (hw->phy.type) {
 154         case ixgbe_phy_tn:
 155                 phy->ops.setup_link = &ixgbe_setup_phy_link_tnx;
 156                 phy->ops.check_link = &ixgbe_check_phy_link_tnx;
 157                 phy->ops.get_firmware_version =
 158                              &ixgbe_get_phy_firmware_version_tnx;
 159                 break;
 160         default:
 161                 break;
 162         }
 163 init_phy_ops_out:
 164         return ret_val;
 165 }
 166
 167 s32 ixgbe_setup_sfp_modules_82599(struct ixgbe_hw *hw)
 168 {
 169         s32 ret_val = IXGBE_SUCCESS;
 170         u16 list_offset, data_offset, data_value;
 171
 172         DEBUGFUNC("ixgbe_setup_sfp_modules_82599");
 173
 174         if (hw->phy.sfp_type != ixgbe_sfp_type_unknown) {
 175                 ixgbe_init_mac_link_ops_82599(hw);
 176
 177                 hw->phy.ops.reset = NULL;
 178
 179                 ret_val = ixgbe_get_sfp_init_sequence_offsets(hw, &list_offset,
 180                                                               &data_offset);
 181                 if (ret_val != IXGBE_SUCCESS)
 182                         goto setup_sfp_out;
 183
 184                 /* PHY config will finish before releasing the semaphore */
 185                 ret_val = hw->mac.ops.acquire_swfw_sync(hw,
 186                                                         IXGBE_GSSR_MAC_CSR_SM);
 187                 if (ret_val != IXGBE_SUCCESS) {
 188                         ret_val = IXGBE_ERR_SWFW_SYNC;
 189                         goto setup_sfp_out;
 190                 }
 191
 192                 if (hw->eeprom.ops.read(hw, ++data_offset, &data_value))
 193                         goto setup_sfp_err;
 194                 while (data_value != 0xffff) {
 195                         IXGBE_WRITE_REG(hw, IXGBE_CORECTL, data_value);
 196                         IXGBE_WRITE_FLUSH(hw);
 197                         if (hw->eeprom.ops.read(hw, ++data_offset, &data_value))
 198                                 goto setup_sfp_err;
 199                 }
 200
 201                 /* Release the semaphore */
 202                 hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_MAC_CSR_SM);
 203                 /* Delay obtaining semaphore again to allow FW access
 204                  * prot_autoc_write uses the semaphore too.
 205                  */
 206                 msec_delay(hw->eeprom.semaphore_delay);
 207
 208                 /* Restart DSP and set SFI mode */
 209                 ret_val = hw->mac.ops.prot_autoc_write(hw,
 210                         hw->mac.orig_autoc | IXGBE_AUTOC_LMS_10G_SERIAL,
 211                         false);
 212
 213                 if (ret_val) {
 214                         DEBUGOUT("sfp module setup not complete\n");
 215                         ret_val = IXGBE_ERR_SFP_SETUP_NOT_COMPLETE;
 216                         goto setup_sfp_out;
 217                 }
 218
 219         }
 220
 221 setup_sfp_out:
 222         return ret_val;
 223
 224 setup_sfp_err:
 225         /* Release the semaphore */
 226         hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_MAC_CSR_SM);
 227         /* Delay obtaining semaphore again to allow FW access */
 228         msec_delay(hw->eeprom.semaphore_delay);
 229         ERROR_REPORT2(IXGBE_ERROR_INVALID_STATE,
 230                       "eeprom read at offset %d failed", data_offset);
 231         return IXGBE_ERR_PHY;
 232 }
 233
 234 /**
 235  *  prot_autoc_read_82599 - Hides MAC differences needed for AUTOC read
 236  *  @hw: pointer to hardware structure
 237  *  @locked: Return the if we locked for this read.
 238  *  @reg_val: Value we read from AUTOC
 239  *
 240  *  For this part (82599) we need to wrap read-modify-writes with a possible
 241  *  FW/SW lock.  It is assumed this lock will be freed with the next
 242  *  prot_autoc_write_82599().
 243  */
 244 s32 prot_autoc_read_82599(struct ixgbe_hw *hw, bool *locked, u32 *reg_val)
 245 {
 246         s32 ret_val;
 247
 248         *locked = false;
 249          /* If LESM is on then we need to hold the SW/FW semaphore. */
 250         if (ixgbe_verify_lesm_fw_enabled_82599(hw)) {
 251                 ret_val = hw->mac.ops.acquire_swfw_sync(hw,
 252                                         IXGBE_GSSR_MAC_CSR_SM);
 253                 if (ret_val != IXGBE_SUCCESS)
 254                         return IXGBE_ERR_SWFW_SYNC;
 255
 256                 *locked = true;
 257         }
 258
 259         *reg_val = IXGBE_READ_REG(hw, IXGBE_AUTOC);
 260         return IXGBE_SUCCESS;
 261 }
 262
 263 /**
 264  * prot_autoc_write_82599 - Hides MAC differences needed for AUTOC write
 265  * @hw: pointer to hardware structure
 266  * @reg_val: value to write to AUTOC
 267  * @locked: bool to indicate whether the SW/FW lock was already taken by
 268  *           previous proc_autoc_read_82599.
 269  *
 270  * This part (82599) may need to hold the SW/FW lock around all writes to
 271  * AUTOC. Likewise after a write we need to do a pipeline reset.
 272  */
 273 s32 prot_autoc_write_82599(struct ixgbe_hw *hw, u32 autoc, bool locked)
 274 {
 275         s32 ret_val = IXGBE_SUCCESS;
 276
 277         /* Blocked by MNG FW so bail */
 278         if (ixgbe_check_reset_blocked(hw))
 279                 goto out;
 280
 281         /* We only need to get the lock if:
 282          *  - We didn't do it already (in the read part of a read-modify-write)
 283          *  - LESM is enabled.
 284          */
 285         if (!locked && ixgbe_verify_lesm_fw_enabled_82599(hw)) {
 286                 ret_val = hw->mac.ops.acquire_swfw_sync(hw,
 287                                         IXGBE_GSSR_MAC_CSR_SM);
 288                 if (ret_val != IXGBE_SUCCESS)
 289                         return IXGBE_ERR_SWFW_SYNC;
 290
 291                 locked = true;
 292         }
 293
 294         IXGBE_WRITE_REG(hw, IXGBE_AUTOC, autoc);
 295         ret_val = ixgbe_reset_pipeline_82599(hw);
 296
 297 out:
 298         /* Free the SW/FW semaphore as we either grabbed it here or
 299          * already had it when this function was called.
 300          */
 301         if (locked)
 302                 hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_MAC_CSR_SM);
 303
 304         return ret_val;
 305 }
 306
 307 /**
 308  *  ixgbe_init_ops_82599 - Inits func ptrs and MAC type
 309  *  @hw: pointer to hardware structure
 310  *
 311  *  Initialize the function pointers and assign the MAC type for 82599.
 312  *  Does not touch the hardware.
 313  **/
 314
 315 s32 ixgbe_init_ops_82599(struct ixgbe_hw *hw)
 316 {
 317         struct ixgbe_mac_info *mac = &hw->mac;
 318         struct ixgbe_phy_info *phy = &hw->phy;
 319         struct ixgbe_eeprom_info *eeprom = &hw->eeprom;
 320         s32 ret_val;
 321
 322         DEBUGFUNC("ixgbe_init_ops_82599");
 323
 324         ixgbe_init_phy_ops_generic(hw);
 325         ret_val = ixgbe_init_ops_generic(hw);
 326
 327         /* PHY */
 328         phy->ops.identify = &ixgbe_identify_phy_82599;
 329         phy->ops.init = &ixgbe_init_phy_ops_82599;
 330
 331         /* MAC */
 332         mac->ops.reset_hw = &ixgbe_reset_hw_82599;
 333         mac->ops.enable_relaxed_ordering = &ixgbe_enable_relaxed_ordering_gen2;
 334         mac->ops.get_media_type = &ixgbe_get_media_type_82599;
 335         mac->ops.get_supported_physical_layer =
 336                                     &ixgbe_get_supported_physical_layer_82599;
 337         mac->ops.disable_sec_rx_path = &ixgbe_disable_sec_rx_path_generic;
 338         mac->ops.enable_sec_rx_path = &ixgbe_enable_sec_rx_path_generic;
 339         mac->ops.enable_rx_dma = &ixgbe_enable_rx_dma_82599;
 340         mac->ops.read_analog_reg8 = &ixgbe_read_analog_reg8_82599;
 341         mac->ops.write_analog_reg8 = &ixgbe_write_analog_reg8_82599;
 342         mac->ops.start_hw = &ixgbe_start_hw_82599;
 343         mac->ops.get_san_mac_addr = &ixgbe_get_san_mac_addr_generic;
 344         mac->ops.set_san_mac_addr = &ixgbe_set_san_mac_addr_generic;
 345         mac->ops.get_device_caps = &ixgbe_get_device_caps_generic;
 346         mac->ops.get_wwn_prefix = &ixgbe_get_wwn_prefix_generic;
 347         mac->ops.get_fcoe_boot_status = &ixgbe_get_fcoe_boot_status_generic;
 348         mac->ops.prot_autoc_read = &prot_autoc_read_82599;
 349         mac->ops.prot_autoc_write = &prot_autoc_write_82599;
 350
 351         /* RAR, Multicast, VLAN */
 352         mac->ops.set_vmdq = &ixgbe_set_vmdq_generic;
 353         mac->ops.set_vmdq_san_mac = &ixgbe_set_vmdq_san_mac_generic;
 354         mac->ops.clear_vmdq = &ixgbe_clear_vmdq_generic;
 355         mac->ops.insert_mac_addr = &ixgbe_insert_mac_addr_generic;
 356         mac->rar_highwater = 1;
 357         mac->ops.set_vfta = &ixgbe_set_vfta_generic;
 358         mac->ops.set_vlvf = &ixgbe_set_vlvf_generic;
 359         mac->ops.clear_vfta = &ixgbe_clear_vfta_generic;
 360         mac->ops.init_uta_tables = &ixgbe_init_uta_tables_generic;
 361         mac->ops.setup_sfp = &ixgbe_setup_sfp_modules_82599;
 362         mac->ops.set_mac_anti_spoofing = &ixgbe_set_mac_anti_spoofing;
 363         mac->ops.set_vlan_anti_spoofing = &ixgbe_set_vlan_anti_spoofing;
 364
 365         /* Link */
 366         mac->ops.get_link_capabilities = &ixgbe_get_link_capabilities_82599;
 367         mac->ops.check_link = &ixgbe_check_mac_link_generic;
 368         mac->ops.setup_rxpba = &ixgbe_set_rxpba_generic;
 369         ixgbe_init_mac_link_ops_82599(hw);
 370
 371         mac->mcft_size          = IXGBE_82599_MC_TBL_SIZE;
 372         mac->vft_size           = IXGBE_82599_VFT_TBL_SIZE;
 373         mac->num_rar_entries    = IXGBE_82599_RAR_ENTRIES;
 374         mac->rx_pb_size         = IXGBE_82599_RX_PB_SIZE;
 375         mac->max_rx_queues      = IXGBE_82599_MAX_RX_QUEUES;
 376         mac->max_tx_queues      = IXGBE_82599_MAX_TX_QUEUES;
 377         mac->max_msix_vectors   = ixgbe_get_pcie_msix_count_generic(hw);
 378
 379         mac->arc_subsystem_valid = (IXGBE_READ_REG(hw, IXGBE_FWSM) &
 380                                    IXGBE_FWSM_MODE_MASK) ? true : false;
 381
 382         hw->mbx.ops.init_params = ixgbe_init_mbx_params_pf;
 383
 384         /* EEPROM */
 385         eeprom->ops.read = &ixgbe_read_eeprom_82599;
 386         eeprom->ops.read_buffer = &ixgbe_read_eeprom_buffer_82599;
 387
 388         /* Manageability interface */
 389         mac->ops.set_fw_drv_ver = &ixgbe_set_fw_drv_ver_generic;
 390
 391         mac->ops.get_thermal_sensor_data =
 392                                          &ixgbe_get_thermal_sensor_data_generic;
 393         mac->ops.init_thermal_sensor_thresh =
 394                                       &ixgbe_init_thermal_sensor_thresh_generic;
 395
 396         mac->ops.get_rtrup2tc = &ixgbe_dcb_get_rtrup2tc_generic;
 397
 398         return ret_val;
 399 }
 400
 401 /**
 402  *  ixgbe_get_link_capabilities_82599 - Determines link capabilities
 403  *  @hw: pointer to hardware structure
 404  *  @speed: pointer to link speed
 405  *  @autoneg: true when autoneg or autotry is enabled
 406  *
 407  *  Determines the link capabilities by reading the AUTOC register.
 408  **/
 409 s32 ixgbe_get_link_capabilities_82599(struct ixgbe_hw *hw,
 410                                       ixgbe_link_speed *speed,
 411                                       bool *autoneg)
 412 {
 413         s32 status = IXGBE_SUCCESS;
 414         u32 autoc = 0;
 415
 416         DEBUGFUNC("ixgbe_get_link_capabilities_82599");
 417
 418
 419         /* Check if 1G SFP module. */
 420         if (hw->phy.sfp_type == ixgbe_sfp_type_1g_cu_core0 ||
 421             hw->phy.sfp_type == ixgbe_sfp_type_1g_cu_core1 ||
 422             hw->phy.sfp_type == ixgbe_sfp_type_1g_lx_core0 ||
 423             hw->phy.sfp_type == ixgbe_sfp_type_1g_lx_core1 ||
 424             hw->phy.sfp_type == ixgbe_sfp_type_1g_sx_core0 ||
 425             hw->phy.sfp_type == ixgbe_sfp_type_1g_sx_core1) {
 426                 *speed = IXGBE_LINK_SPEED_1GB_FULL;
 427                 *autoneg = true;
 428                 goto out;
 429         }
 430
 431         /*
 432          * Determine link capabilities based on the stored value of AUTOC,
 433          * which represents EEPROM defaults.  If AUTOC value has not
 434          * been stored, use the current register values.
 435          */
 436         if (hw->mac.orig_link_settings_stored)
 437                 autoc = hw->mac.orig_autoc;
 438         else
 439                 autoc = IXGBE_READ_REG(hw, IXGBE_AUTOC);
 440
 441         switch (autoc & IXGBE_AUTOC_LMS_MASK) {
 442         case IXGBE_AUTOC_LMS_1G_LINK_NO_AN:
 443                 *speed = IXGBE_LINK_SPEED_1GB_FULL;
 444                 *autoneg = false;
 445                 break;
 446
 447         case IXGBE_AUTOC_LMS_10G_LINK_NO_AN:
 448                 *speed = IXGBE_LINK_SPEED_10GB_FULL;
 449                 *autoneg = false;
 450                 break;
 451
 452         case IXGBE_AUTOC_LMS_1G_AN:
 453                 *speed = IXGBE_LINK_SPEED_1GB_FULL;
 454                 *autoneg = true;
 455                 break;
 456
 457         case IXGBE_AUTOC_LMS_10G_SERIAL:
 458                 *speed = IXGBE_LINK_SPEED_10GB_FULL;
 459                 *autoneg = false;
 460                 break;
 461
 462         case IXGBE_AUTOC_LMS_KX4_KX_KR:
 463         case IXGBE_AUTOC_LMS_KX4_KX_KR_1G_AN:
 464                 *speed = IXGBE_LINK_SPEED_UNKNOWN;
 465                 if (autoc & IXGBE_AUTOC_KR_SUPP)
 466                         *speed |= IXGBE_LINK_SPEED_10GB_FULL;
 467                 if (autoc & IXGBE_AUTOC_KX4_SUPP)
 468                         *speed |= IXGBE_LINK_SPEED_10GB_FULL;
 469                 if (autoc & IXGBE_AUTOC_KX_SUPP)
 470                         *speed |= IXGBE_LINK_SPEED_1GB_FULL;
 471                 *autoneg = true;
 472                 break;
 473
 474         case IXGBE_AUTOC_LMS_KX4_KX_KR_SGMII:
 475                 *speed = IXGBE_LINK_SPEED_100_FULL;
 476                 if (autoc & IXGBE_AUTOC_KR_SUPP)
 477                         *speed |= IXGBE_LINK_SPEED_10GB_FULL;
 478                 if (autoc & IXGBE_AUTOC_KX4_SUPP)
 479                         *speed |= IXGBE_LINK_SPEED_10GB_FULL;
 480                 if (autoc & IXGBE_AUTOC_KX_SUPP)
 481                         *speed |= IXGBE_LINK_SPEED_1GB_FULL;
 482                 *autoneg = true;
 483                 break;
 484
 485         case IXGBE_AUTOC_LMS_SGMII_1G_100M:
 486                 *speed = IXGBE_LINK_SPEED_1GB_FULL | IXGBE_LINK_SPEED_100_FULL;
 487                 *autoneg = false;
 488                 break;
 489
 490         default:
 491                 status = IXGBE_ERR_LINK_SETUP;
 492                 goto out;
 493                 break;
 494         }
 495
 496         if (hw->phy.multispeed_fiber) {
 497                 *speed |= IXGBE_LINK_SPEED_10GB_FULL |
 498                           IXGBE_LINK_SPEED_1GB_FULL;
 499
 500                 /* QSFP must not enable full auto-negotiation
 501                  * Limited autoneg is enabled at 1G
 502                  */
 503                 if (hw->phy.media_type == ixgbe_media_type_fiber_qsfp)
 504                         *autoneg = false;
 505                 else
 506                         *autoneg = true;
 507         }
 508
 509 out:
 510         return status;
 511 }
 512
 513 /**
 514  *  ixgbe_get_media_type_82599 - Get media type
 515  *  @hw: pointer to hardware structure
 516  *
 517  *  Returns the media type (fiber, copper, backplane)
 518  **/
 519 enum ixgbe_media_type ixgbe_get_media_type_82599(struct ixgbe_hw *hw)
 520 {
 521         enum ixgbe_media_type media_type;
 522
 523         DEBUGFUNC("ixgbe_get_media_type_82599");
 524
 525         /* Detect if there is a copper PHY attached. */
 526         switch (hw->phy.type) {
 527         case ixgbe_phy_cu_unknown:
 528         case ixgbe_phy_tn:
 529                 media_type = ixgbe_media_type_copper;
 530                 goto out;
 531         default:
 532                 break;
 533         }
 534
 535         switch (hw->device_id) {
 536         case IXGBE_DEV_ID_82599_KX4:
 537         case IXGBE_DEV_ID_82599_KX4_MEZZ:
 538         case IXGBE_DEV_ID_82599_COMBO_BACKPLANE:
 539         case IXGBE_DEV_ID_82599_KR:
 540         case IXGBE_DEV_ID_82599_BACKPLANE_FCOE:
 541         case IXGBE_DEV_ID_82599_XAUI_LOM:
 542                 /* Default device ID is mezzanine card KX/KX4 */
 543                 media_type = ixgbe_media_type_backplane;
 544                 break;
 545         case IXGBE_DEV_ID_82599_SFP:
 546         case IXGBE_DEV_ID_82599_SFP_FCOE:
 547         case IXGBE_DEV_ID_82599_SFP_EM:
 548         case IXGBE_DEV_ID_82599_SFP_SF2:
 549         case IXGBE_DEV_ID_82599_SFP_SF_QP:
 550         case IXGBE_DEV_ID_82599EN_SFP:
 551                 media_type = ixgbe_media_type_fiber;
 552                 break;
 553         case IXGBE_DEV_ID_82599_CX4:
 554                 media_type = ixgbe_media_type_cx4;
 555                 break;
 556         case IXGBE_DEV_ID_82599_T3_LOM:
 557                 media_type = ixgbe_media_type_copper;
 558                 break;
 559         case IXGBE_DEV_ID_82599_LS:
 560                 media_type = ixgbe_media_type_fiber_lco;
 561                 break;
 562         case IXGBE_DEV_ID_82599_QSFP_SF_QP:
 563                 media_type = ixgbe_media_type_fiber_qsfp;
 564                 break;
 565         default:
 566                 media_type = ixgbe_media_type_unknown;
 567                 break;
 568         }
 569 out:
 570         return media_type;
 571 }
 572
 573 /**
 574  *  ixgbe_stop_mac_link_on_d3_82599 - Disables link on D3
 575  *  @hw: pointer to hardware structure
 576  *
 577  *  Disables link during D3 power down sequence.
 578  *
 579  **/
 580 void ixgbe_stop_mac_link_on_d3_82599(struct ixgbe_hw *hw)
 581 {
 582         u32 autoc2_reg, fwsm;
 583         u16 ee_ctrl_2 = 0;
 584
 585         DEBUGFUNC("ixgbe_stop_mac_link_on_d3_82599");
 586         ixgbe_read_eeprom(hw, IXGBE_EEPROM_CTRL_2, &ee_ctrl_2);
 587
 588         /* Check to see if MNG FW could be enabled */
 589         fwsm = IXGBE_READ_REG(hw, IXGBE_FWSM);
 590
 591         if (((fwsm & IXGBE_FWSM_MODE_MASK) != IXGBE_FWSM_FW_MODE_PT) &&
 592             !hw->wol_enabled &&
 593             ee_ctrl_2 & IXGBE_EEPROM_CCD_BIT) {
 594                 autoc2_reg = IXGBE_READ_REG(hw, IXGBE_AUTOC2);
 595                 autoc2_reg |= IXGBE_AUTOC2_LINK_DISABLE_ON_D3_MASK;
 596                 IXGBE_WRITE_REG(hw, IXGBE_AUTOC2, autoc2_reg);
 597         }
 598 }
 599
 600 /**
 601  *  ixgbe_start_mac_link_82599 - Setup MAC link settings
 602  *  @hw: pointer to hardware structure
 603  *  @autoneg_wait_to_complete: true when waiting for completion is needed
 604  *
 605  *  Configures link settings based on values in the ixgbe_hw struct.
 606  *  Restarts the link.  Performs autonegotiation if needed.
 607  **/
 608 s32 ixgbe_start_mac_link_82599(struct ixgbe_hw *hw,
 609                                bool autoneg_wait_to_complete)
 610 {
 611         u32 autoc_reg;
 612         u32 links_reg;
 613         u32 i;
 614         s32 status = IXGBE_SUCCESS;
 615         bool got_lock = false;
 616
 617         DEBUGFUNC("ixgbe_start_mac_link_82599");
 618
 619
 620         /*  reset_pipeline requires us to hold this lock as it writes to
 621          *  AUTOC.
 622          */
 623         if (ixgbe_verify_lesm_fw_enabled_82599(hw)) {
 624                 status = hw->mac.ops.acquire_swfw_sync(hw,
 625                                                        IXGBE_GSSR_MAC_CSR_SM);
 626                 if (status != IXGBE_SUCCESS)
 627                         goto out;
 628
 629                 got_lock = true;
 630         }
 631
 632         /* Restart link */
 633         ixgbe_reset_pipeline_82599(hw);
 634
 635         if (got_lock)
 636                 hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_MAC_CSR_SM);
 637
 638         /* Only poll for autoneg to complete if specified to do so */
 639         if (autoneg_wait_to_complete) {
 640                 autoc_reg = IXGBE_READ_REG(hw, IXGBE_AUTOC);
 641                 if ((autoc_reg & IXGBE_AUTOC_LMS_MASK) ==
 642                      IXGBE_AUTOC_LMS_KX4_KX_KR ||
 643                     (autoc_reg & IXGBE_AUTOC_LMS_MASK) ==
 644                      IXGBE_AUTOC_LMS_KX4_KX_KR_1G_AN ||
 645                     (autoc_reg & IXGBE_AUTOC_LMS_MASK) ==
 646                      IXGBE_AUTOC_LMS_KX4_KX_KR_SGMII) {
 647                         links_reg = 0; /* Just in case Autoneg time = 0 */
 648                         for (i = 0; i < IXGBE_AUTO_NEG_TIME; i++) {
 649                                 links_reg = IXGBE_READ_REG(hw, IXGBE_LINKS);
 650                                 if (links_reg & IXGBE_LINKS_KX_AN_COMP)
 651                                         break;
 652                                 msec_delay(100);
 653                         }
 654                         if (!(links_reg & IXGBE_LINKS_KX_AN_COMP)) {
 655                                 status = IXGBE_ERR_AUTONEG_NOT_COMPLETE;
 656                                 DEBUGOUT("Autoneg did not complete.\n");
 657                         }
 658                 }
 659         }
 660
 661         /* Add delay to filter out noises during initial link setup */
 662         msec_delay(50);
 663
 664 out:
 665         return status;
 666 }
 667
 668 /**
 669  *  ixgbe_disable_tx_laser_multispeed_fiber - Disable Tx laser
 670  *  @hw: pointer to hardware structure
 671  *
 672  *  The base drivers may require better control over SFP+ module
 673  *  PHY states.  This includes selectively shutting down the Tx
 674  *  laser on the PHY, effectively halting physical link.
 675  **/
 676 void ixgbe_disable_tx_laser_multispeed_fiber(struct ixgbe_hw *hw)
 677 {
 678         u32 esdp_reg = IXGBE_READ_REG(hw, IXGBE_ESDP);
 679
 680         /* Blocked by MNG FW so bail */
 681         if (ixgbe_check_reset_blocked(hw))
 682                 return;
 683
 684         /* Disable Tx laser; allow 100us to go dark per spec */
 685         esdp_reg |= IXGBE_ESDP_SDP3;
 686         IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp_reg);
 687         IXGBE_WRITE_FLUSH(hw);
 688         usec_delay(100);
 689 }
 690
 691 /**
 692  *  ixgbe_enable_tx_laser_multispeed_fiber - Enable Tx laser
 693  *  @hw: pointer to hardware structure
 694  *
 695  *  The base drivers may require better control over SFP+ module
 696  *  PHY states.  This includes selectively turning on the Tx
 697  *  laser on the PHY, effectively starting physical link.
 698  **/
 699 void ixgbe_enable_tx_laser_multispeed_fiber(struct ixgbe_hw *hw)
 700 {
 701         u32 esdp_reg = IXGBE_READ_REG(hw, IXGBE_ESDP);
 702
 703         /* Enable Tx laser; allow 100ms to light up */
 704         esdp_reg &= ~IXGBE_ESDP_SDP3;
 705         IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp_reg);
 706         IXGBE_WRITE_FLUSH(hw);
 707         msec_delay(100);
 708 }
 709
 710 /**
 711  *  ixgbe_flap_tx_laser_multispeed_fiber - Flap Tx laser
 712  *  @hw: pointer to hardware structure
 713  *
 714  *  When the driver changes the link speeds that it can support,
 715  *  it sets autotry_restart to true to indicate that we need to
 716  *  initiate a new autotry session with the link partner.  To do
 717  *  so, we set the speed then disable and re-enable the Tx laser, to
 718  *  alert the link partner that it also needs to restart autotry on its
 719  *  end.  This is consistent with true clause 37 autoneg, which also
 720  *  involves a loss of signal.
 721  **/
 722 void ixgbe_flap_tx_laser_multispeed_fiber(struct ixgbe_hw *hw)
 723 {
 724         DEBUGFUNC("ixgbe_flap_tx_laser_multispeed_fiber");
 725
 726         /* Blocked by MNG FW so bail */
 727         if (ixgbe_check_reset_blocked(hw))
 728                 return;
 729
 730         if (hw->mac.autotry_restart) {
 731                 ixgbe_disable_tx_laser_multispeed_fiber(hw);
 732                 ixgbe_enable_tx_laser_multispeed_fiber(hw);
 733                 hw->mac.autotry_restart = false;
 734         }
 735 }
 736
 737
 738 /**
 739  *  ixgbe_setup_mac_link_multispeed_fiber - Set MAC link speed
 740  *  @hw: pointer to hardware structure
 741  *  @speed: new link speed
 742  *  @autoneg_wait_to_complete: true when waiting for completion is needed
 743  *
 744  *  Set the link speed in the AUTOC register and restarts link.
 745  **/
 746 s32 ixgbe_setup_mac_link_multispeed_fiber(struct ixgbe_hw *hw,
 747                                      ixgbe_link_speed speed,
 748                                      bool autoneg_wait_to_complete)
 749 {
 750         s32 status = IXGBE_SUCCESS;
 751         ixgbe_link_speed link_speed = IXGBE_LINK_SPEED_UNKNOWN;
 752         ixgbe_link_speed highest_link_speed = IXGBE_LINK_SPEED_UNKNOWN;
 753         u32 speedcnt = 0;
 754         u32 esdp_reg = IXGBE_READ_REG(hw, IXGBE_ESDP);
 755         u32 i = 0;
 756         bool autoneg, link_up = false;
 757
 758         DEBUGFUNC("ixgbe_setup_mac_link_multispeed_fiber");
 759
 760         /* Mask off requested but non-supported speeds */
 761         status = ixgbe_get_link_capabilities(hw, &link_speed, &autoneg);
 762         if (status != IXGBE_SUCCESS)
 763                 return status;
 764
 765         speed &= link_speed;
 766
 767         /*
 768          * Try each speed one by one, highest priority first.  We do this in
 769          * software because 10gb fiber doesn't support speed autonegotiation.
 770          */
 771         if (speed & IXGBE_LINK_SPEED_10GB_FULL) {
 772                 speedcnt++;
 773                 highest_link_speed = IXGBE_LINK_SPEED_10GB_FULL;
 774
 775                 /* If we already have link at this speed, just jump out */
 776                 status = ixgbe_check_link(hw, &link_speed, &link_up, false);
 777                 if (status != IXGBE_SUCCESS)
 778                         return status;
 779
 780                 if ((link_speed == IXGBE_LINK_SPEED_10GB_FULL) && link_up)
 781                         goto out;
 782
 783                 /* Set the module link speed */
 784                 switch (hw->phy.media_type) {
 785                 case ixgbe_media_type_fiber:
 786                         esdp_reg |= (IXGBE_ESDP_SDP5_DIR | IXGBE_ESDP_SDP5);
 787                         IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp_reg);
 788                         IXGBE_WRITE_FLUSH(hw);
 789                         break;
 790                 case ixgbe_media_type_fiber_qsfp:
 791                         /* QSFP module automatically detects MAC link speed */
 792                         break;
 793                 default:
 794                         DEBUGOUT("Unexpected media type.\n");
 795                         break;
 796                 }
 797
 798                 /* Allow module to change analog characteristics (1G->10G) */
 799                 msec_delay(40);
 800
 801                 status = ixgbe_setup_mac_link_82599(hw,
 802                                                     IXGBE_LINK_SPEED_10GB_FULL,
 803                                                     autoneg_wait_to_complete);
 804                 if (status != IXGBE_SUCCESS)
 805                         return status;
 806
 807                 /* Flap the tx laser if it has not already been done */
 808                 ixgbe_flap_tx_laser(hw);
 809
 810                 /*
 811                  * Wait for the controller to acquire link.  Per IEEE 802.3ap,
 812                  * Section 73.10.2, we may have to wait up to 500ms if KR is
 813                  * attempted.  82599 uses the same timing for 10g SFI.
 814                  */
 815                 for (i = 0; i < 5; i++) {
 816                         /* Wait for the link partner to also set speed */
 817                         msec_delay(100);
 818
 819                         /* If we have link, just jump out */
 820                         status = ixgbe_check_link(hw, &link_speed,
 821                                                   &link_up, false);
 822                         if (status != IXGBE_SUCCESS)
 823                                 return status;
 824
 825                         if (link_up)
 826                                 goto out;
 827                 }
 828         }
 829
 830         if (speed & IXGBE_LINK_SPEED_1GB_FULL) {
 831                 speedcnt++;
 832                 if (highest_link_speed == IXGBE_LINK_SPEED_UNKNOWN)
 833                         highest_link_speed = IXGBE_LINK_SPEED_1GB_FULL;
 834
 835                 /* If we already have link at this speed, just jump out */
 836                 status = ixgbe_check_link(hw, &link_speed, &link_up, false);
 837                 if (status != IXGBE_SUCCESS)
 838                         return status;
 839
 840                 if ((link_speed == IXGBE_LINK_SPEED_1GB_FULL) && link_up)
 841                         goto out;
 842
 843                 /* Set the module link speed */
 844                 switch (hw->phy.media_type) {
 845                 case ixgbe_media_type_fiber:
 846                         esdp_reg &= ~IXGBE_ESDP_SDP5;
 847                         esdp_reg |= IXGBE_ESDP_SDP5_DIR;
 848                         IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp_reg);
 849                         IXGBE_WRITE_FLUSH(hw);
 850                         break;
 851                 case ixgbe_media_type_fiber_qsfp:
 852                         /* QSFP module automatically detects link speed */
 853                         break;
 854                 default:
 855                         DEBUGOUT("Unexpected media type.\n");
 856                         break;
 857                 }
 858
 859                 /* Allow module to change analog characteristics (10G->1G) */
 860                 msec_delay(40);
 861
 862                 status = ixgbe_setup_mac_link_82599(hw,
 863                                                     IXGBE_LINK_SPEED_1GB_FULL,
 864                                                     autoneg_wait_to_complete);
 865                 if (status != IXGBE_SUCCESS)
 866                         return status;
 867
 868                 /* Flap the Tx laser if it has not already been done */
 869                 ixgbe_flap_tx_laser(hw);
 870
 871                 /* Wait for the link partner to also set speed */
 872                 msec_delay(100);
 873
 874                 /* If we have link, just jump out */
 875                 status = ixgbe_check_link(hw, &link_speed, &link_up, false);
 876                 if (status != IXGBE_SUCCESS)
 877                         return status;
 878
 879                 if (link_up)
 880                         goto out;
 881         }
 882
 883         /*
 884          * We didn't get link.  Configure back to the highest speed we tried,
 885          * (if there was more than one).  We call ourselves back with just the
 886          * single highest speed that the user requested.
 887          */
 888         if (speedcnt > 1)
 889                 status = ixgbe_setup_mac_link_multispeed_fiber(hw,
 890                         highest_link_speed, autoneg_wait_to_complete);
 891
 892 out:
 893         /* Set autoneg_advertised value based on input link speed */
 894         hw->phy.autoneg_advertised = 0;
 895
 896         if (speed & IXGBE_LINK_SPEED_10GB_FULL)
 897                 hw->phy.autoneg_advertised |= IXGBE_LINK_SPEED_10GB_FULL;
 898
 899         if (speed & IXGBE_LINK_SPEED_1GB_FULL)
 900                 hw->phy.autoneg_advertised |= IXGBE_LINK_SPEED_1GB_FULL;
 901
 902         return status;
 903 }
 904
 905 /**
 906  *  ixgbe_setup_mac_link_smartspeed - Set MAC link speed using SmartSpeed
 907  *  @hw: pointer to hardware structure
 908  *  @speed: new link speed
 909  *  @autoneg_wait_to_complete: true when waiting for completion is needed
 910  *
 911  *  Implements the Intel SmartSpeed algorithm.
 912  **/
 913 s32 ixgbe_setup_mac_link_smartspeed(struct ixgbe_hw *hw,
 914                                     ixgbe_link_speed speed,
 915                                     bool autoneg_wait_to_complete)
 916 {
 917         s32 status = IXGBE_SUCCESS;
 918         ixgbe_link_speed link_speed = IXGBE_LINK_SPEED_UNKNOWN;
 919         s32 i, j;
 920         bool link_up = false;
 921         u32 autoc_reg = IXGBE_READ_REG(hw, IXGBE_AUTOC);
 922
 923         DEBUGFUNC("ixgbe_setup_mac_link_smartspeed");
 924
 925          /* Set autoneg_advertised value based on input link speed */
 926         hw->phy.autoneg_advertised = 0;
 927
 928         if (speed & IXGBE_LINK_SPEED_10GB_FULL)
 929                 hw->phy.autoneg_advertised |= IXGBE_LINK_SPEED_10GB_FULL;
 930
 931         if (speed & IXGBE_LINK_SPEED_1GB_FULL)
 932                 hw->phy.autoneg_advertised |= IXGBE_LINK_SPEED_1GB_FULL;
 933
 934         if (speed & IXGBE_LINK_SPEED_100_FULL)
 935                 hw->phy.autoneg_advertised |= IXGBE_LINK_SPEED_100_FULL;
 936
 937         /*
 938          * Implement Intel SmartSpeed algorithm.  SmartSpeed will reduce the
 939          * autoneg advertisement if link is unable to be established at the
 940          * highest negotiated rate.  This can sometimes happen due to integrity
 941          * issues with the physical media connection.
 942          */
 943
 944         /* First, try to get link with full advertisement */
 945         hw->phy.smart_speed_active = false;
 946         for (j = 0; j < IXGBE_SMARTSPEED_MAX_RETRIES; j++) {
 947                 status = ixgbe_setup_mac_link_82599(hw, speed,
 948                                                     autoneg_wait_to_complete);
 949                 if (status != IXGBE_SUCCESS)
 950                         goto out;
 951
 952                 /*
 953                  * Wait for the controller to acquire link.  Per IEEE 802.3ap,
 954                  * Section 73.10.2, we may have to wait up to 500ms if KR is
 955                  * attempted, or 200ms if KX/KX4/BX/BX4 is attempted, per
 956                  * Table 9 in the AN MAS.
 957                  */
 958                 for (i = 0; i < 5; i++) {
 959                         msec_delay(100);
 960
 961                         /* If we have link, just jump out */
 962                         status = ixgbe_check_link(hw, &link_speed, &link_up,
 963                                                   false);
 964                         if (status != IXGBE_SUCCESS)
 965                                 goto out;
 966
 967                         if (link_up)
 968                                 goto out;
 969                 }
 970         }
 971
 972         /*
 973          * We didn't get link.  If we advertised KR plus one of KX4/KX
 974          * (or BX4/BX), then disable KR and try again.
 975          */
 976         if (((autoc_reg & IXGBE_AUTOC_KR_SUPP) == 0) ||
 977             ((autoc_reg & IXGBE_AUTOC_KX4_KX_SUPP_MASK) == 0))
 978                 goto out;
 979
 980         /* Turn SmartSpeed on to disable KR support */
 981         hw->phy.smart_speed_active = true;
 982         status = ixgbe_setup_mac_link_82599(hw, speed,
 983                                             autoneg_wait_to_complete);
 984         if (status != IXGBE_SUCCESS)
 985                 goto out;
 986
 987         /*
 988          * Wait for the controller to acquire link.  600ms will allow for
 989          * the AN link_fail_inhibit_timer as well for multiple cycles of
 990          * parallel detect, both 10g and 1g. This allows for the maximum
 991          * connect attempts as defined in the AN MAS table 73-7.
 992          */
 993         for (i = 0; i < 6; i++) {
 994                 msec_delay(100);
 995
 996                 /* If we have link, just jump out */
 997                 status = ixgbe_check_link(hw, &link_speed, &link_up, false);
 998                 if (status != IXGBE_SUCCESS)
 999                         goto out;
1000
1001                 if (link_up)
1002                         goto out;
1003         }
1004
1005         /* We didn't get link.  Turn SmartSpeed back off. */
1006         hw->phy.smart_speed_active = false;
1007         status = ixgbe_setup_mac_link_82599(hw, speed,
1008                                             autoneg_wait_to_complete);
1009
1010 out:
1011         if (link_up && (link_speed == IXGBE_LINK_SPEED_1GB_FULL))
1012                 DEBUGOUT("Smartspeed has downgraded the link speed "
1013                 "from the maximum advertised\n");
1014         return status;
1015 }
1016
1017 /**
1018  *  ixgbe_setup_mac_link_82599 - Set MAC link speed
1019  *  @hw: pointer to hardware structure
1020  *  @speed: new link speed
1021  *  @autoneg_wait_to_complete: true when waiting for completion is needed
1022  *
1023  *  Set the link speed in the AUTOC register and restarts link.
1024  **/
1025 s32 ixgbe_setup_mac_link_82599(struct ixgbe_hw *hw,
1026                                ixgbe_link_speed speed,
1027                                bool autoneg_wait_to_complete)
1028 {
1029         bool autoneg = false;
1030         s32 status = IXGBE_SUCCESS;
1031         u32 pma_pmd_1g, link_mode;
1032         u32 current_autoc = IXGBE_READ_REG(hw, IXGBE_AUTOC); /* holds the value of AUTOC register at this current point in time */
1033         u32 orig_autoc = 0; /* holds the cached value of AUTOC register */
1034         u32 autoc = current_autoc; /* Temporary variable used for comparison purposes */
1035         u32 autoc2 = IXGBE_READ_REG(hw, IXGBE_AUTOC2);
1036         u32 pma_pmd_10g_serial = autoc2 & IXGBE_AUTOC2_10G_SERIAL_PMA_PMD_MASK;
1037         u32 links_reg;
1038         u32 i;
1039         ixgbe_link_speed link_capabilities = IXGBE_LINK_SPEED_UNKNOWN;
1040
1041         DEBUGFUNC("ixgbe_setup_mac_link_82599");
1042
1043         /* Check to see if speed passed in is supported. */
1044         status = ixgbe_get_link_capabilities(hw, &link_capabilities, &autoneg);
1045         if (status)
1046                 goto out;
1047
1048         speed &= link_capabilities;
1049
1050         if (speed == IXGBE_LINK_SPEED_UNKNOWN) {
1051                 status = IXGBE_ERR_LINK_SETUP;
1052                 goto out;
1053         }
1054
1055         /* Use stored value (EEPROM defaults) of AUTOC to find KR/KX4 support*/
1056         if (hw->mac.orig_link_settings_stored)
1057                 orig_autoc = hw->mac.orig_autoc;
1058         else
1059                 orig_autoc = autoc;
1060
1061         link_mode = autoc & IXGBE_AUTOC_LMS_MASK;
1062         pma_pmd_1g = autoc & IXGBE_AUTOC_1G_PMA_PMD_MASK;
1063
1064         if (link_mode == IXGBE_AUTOC_LMS_KX4_KX_KR ||
1065             link_mode == IXGBE_AUTOC_LMS_KX4_KX_KR_1G_AN ||
1066             link_mode == IXGBE_AUTOC_LMS_KX4_KX_KR_SGMII) {
1067                 /* Set KX4/KX/KR support according to speed requested */
1068                 autoc &= ~(IXGBE_AUTOC_KX4_KX_SUPP_MASK | IXGBE_AUTOC_KR_SUPP);
1069                 if (speed & IXGBE_LINK_SPEED_10GB_FULL) {
1070                         if (orig_autoc & IXGBE_AUTOC_KX4_SUPP)
1071                                 autoc |= IXGBE_AUTOC_KX4_SUPP;
1072                         if ((orig_autoc & IXGBE_AUTOC_KR_SUPP) &&
1073                             (hw->phy.smart_speed_active == false))
1074                                 autoc |= IXGBE_AUTOC_KR_SUPP;
1075                 }
1076                 if (speed & IXGBE_LINK_SPEED_1GB_FULL)
1077                         autoc |= IXGBE_AUTOC_KX_SUPP;
1078         } else if ((pma_pmd_1g == IXGBE_AUTOC_1G_SFI) &&
1079                    (link_mode == IXGBE_AUTOC_LMS_1G_LINK_NO_AN ||
1080                     link_mode == IXGBE_AUTOC_LMS_1G_AN)) {
1081                 /* Switch from 1G SFI to 10G SFI if requested */
1082                 if ((speed == IXGBE_LINK_SPEED_10GB_FULL) &&
1083                     (pma_pmd_10g_serial == IXGBE_AUTOC2_10G_SFI)) {
1084                         autoc &= ~IXGBE_AUTOC_LMS_MASK;
1085                         autoc |= IXGBE_AUTOC_LMS_10G_SERIAL;
1086                 }
1087         } else if ((pma_pmd_10g_serial == IXGBE_AUTOC2_10G_SFI) &&
1088                    (link_mode == IXGBE_AUTOC_LMS_10G_SERIAL)) {
1089                 /* Switch from 10G SFI to 1G SFI if requested */
1090                 if ((speed == IXGBE_LINK_SPEED_1GB_FULL) &&
1091                     (pma_pmd_1g == IXGBE_AUTOC_1G_SFI)) {
1092                         autoc &= ~IXGBE_AUTOC_LMS_MASK;
1093                         if (autoneg || hw->phy.type == ixgbe_phy_qsfp_intel)
1094                                 autoc |= IXGBE_AUTOC_LMS_1G_AN;
1095                         else
1096                                 autoc |= IXGBE_AUTOC_LMS_1G_LINK_NO_AN;
1097                 }
1098         }
1099
1100         if (autoc != current_autoc) {
1101                 /* Restart link */
1102                 status = hw->mac.ops.prot_autoc_write(hw, autoc, false);
1103                 if (status != IXGBE_SUCCESS)
1104                         goto out;
1105
1106                 /* Only poll for autoneg to complete if specified to do so */
1107                 if (autoneg_wait_to_complete) {
1108                         if (link_mode == IXGBE_AUTOC_LMS_KX4_KX_KR ||
1109                             link_mode == IXGBE_AUTOC_LMS_KX4_KX_KR_1G_AN ||
1110                             link_mode == IXGBE_AUTOC_LMS_KX4_KX_KR_SGMII) {
1111                                 links_reg = 0; /*Just in case Autoneg time=0*/
1112                                 for (i = 0; i < IXGBE_AUTO_NEG_TIME; i++) {
1113                                         links_reg =
1114                                                IXGBE_READ_REG(hw, IXGBE_LINKS);
1115                                         if (links_reg & IXGBE_LINKS_KX_AN_COMP)
1116                                                 break;
1117                                         msec_delay(100);
1118                                 }
1119                                 if (!(links_reg & IXGBE_LINKS_KX_AN_COMP)) {
1120                                         status =
1121                                                 IXGBE_ERR_AUTONEG_NOT_COMPLETE;
1122                                         DEBUGOUT("Autoneg did not complete.\n");
1123                                 }
1124                         }
1125                 }
1126
1127                 /* Add delay to filter out noises during initial link setup */
1128                 msec_delay(50);
1129         }
1130
1131 out:
1132         return status;
1133 }
1134
1135 /**
1136  *  ixgbe_setup_copper_link_82599 - Set the PHY autoneg advertised field
1137  *  @hw: pointer to hardware structure
1138  *  @speed: new link speed
1139  *  @autoneg_wait_to_complete: true if waiting is needed to complete
1140  *
1141  *  Restarts link on PHY and MAC based on settings passed in.
1142  **/
1143 STATIC s32 ixgbe_setup_copper_link_82599(struct ixgbe_hw *hw,
1144                                          ixgbe_link_speed speed,
1145                                          bool autoneg_wait_to_complete)
1146 {
1147         s32 status;
1148
1149         DEBUGFUNC("ixgbe_setup_copper_link_82599");
1150
1151         /* Setup the PHY according to input speed */
1152         status = hw->phy.ops.setup_link_speed(hw, speed,
1153                                               autoneg_wait_to_complete);
1154         /* Set up MAC */
1155         ixgbe_start_mac_link_82599(hw, autoneg_wait_to_complete);
1156
1157         return status;
1158 }
1159
1160 /**
1161  *  ixgbe_reset_hw_82599 - Perform hardware reset
1162  *  @hw: pointer to hardware structure
1163  *
1164  *  Resets the hardware by resetting the transmit and receive units, masks
1165  *  and clears all interrupts, perform a PHY reset, and perform a link (MAC)
1166  *  reset.
1167  **/
1168 s32 ixgbe_reset_hw_82599(struct ixgbe_hw *hw)
1169 {
1170         ixgbe_link_speed link_speed;
1171         s32 status;
1172         u32 ctrl = 0;
1173         u32 i, autoc, autoc2;
1174         u32 curr_lms;
1175         bool link_up = false;
1176
1177         DEBUGFUNC("ixgbe_reset_hw_82599");
1178
1179         /* Call adapter stop to disable tx/rx and clear interrupts */
1180         status = hw->mac.ops.stop_adapter(hw);
1181         if (status != IXGBE_SUCCESS)
1182                 goto reset_hw_out;
1183
1184         /* flush pending Tx transactions */
1185         ixgbe_clear_tx_pending(hw);
1186
1187         /* PHY ops must be identified and initialized prior to reset */
1188
1189         /* Identify PHY and related function pointers */
1190         status = hw->phy.ops.init(hw);
1191
1192         if (status == IXGBE_ERR_SFP_NOT_SUPPORTED)
1193                 goto reset_hw_out;
1194
1195         /* Setup SFP module if there is one present. */
1196         if (hw->phy.sfp_setup_needed) {
1197                 status = hw->mac.ops.setup_sfp(hw);
1198                 hw->phy.sfp_setup_needed = false;
1199         }
1200
1201         if (status == IXGBE_ERR_SFP_NOT_SUPPORTED)
1202                 goto reset_hw_out;
1203
1204         /* Reset PHY */
1205         if (hw->phy.reset_disable == false && hw->phy.ops.reset != NULL)
1206                 hw->phy.ops.reset(hw);
1207
1208         /* remember AUTOC from before we reset */
1209         curr_lms = IXGBE_READ_REG(hw, IXGBE_AUTOC) & IXGBE_AUTOC_LMS_MASK;
1210
1211 mac_reset_top:
1212         /*
1213          * Issue global reset to the MAC.  Needs to be SW reset if link is up.
1214          * If link reset is used when link is up, it might reset the PHY when
1215          * mng is using it.  If link is down or the flag to force full link
1216          * reset is set, then perform link reset.
1217          */
1218         ctrl = IXGBE_CTRL_LNK_RST;
1219         if (!hw->force_full_reset) {
1220                 hw->mac.ops.check_link(hw, &link_speed, &link_up, false);
1221                 if (link_up)
1222                         ctrl = IXGBE_CTRL_RST;
1223         }
1224
1225         ctrl |= IXGBE_READ_REG(hw, IXGBE_CTRL);
1226         IXGBE_WRITE_REG(hw, IXGBE_CTRL, ctrl);
1227         IXGBE_WRITE_FLUSH(hw);
1228
1229         /* Poll for reset bit to self-clear meaning reset is complete */
1230         for (i = 0; i < 10; i++) {
1231                 usec_delay(1);
1232                 ctrl = IXGBE_READ_REG(hw, IXGBE_CTRL);
1233                 if (!(ctrl & IXGBE_CTRL_RST_MASK))
1234                         break;
1235         }
1236
1237         if (ctrl & IXGBE_CTRL_RST_MASK) {
1238                 status = IXGBE_ERR_RESET_FAILED;
1239                 DEBUGOUT("Reset polling failed to complete.\n");
1240         }
1241
1242         msec_delay(50);
1243
1244         /*
1245          * Double resets are required for recovery from certain error
1246          * conditions.  Between resets, it is necessary to stall to
1247          * allow time for any pending HW events to complete.
1248          */
1249         if (hw->mac.flags & IXGBE_FLAGS_DOUBLE_RESET_REQUIRED) {
1250                 hw->mac.flags &= ~IXGBE_FLAGS_DOUBLE_RESET_REQUIRED;
1251                 goto mac_reset_top;
1252         }
1253
1254         /*
1255          * Store the original AUTOC/AUTOC2 values if they have not been
1256          * stored off yet.  Otherwise restore the stored original
1257          * values since the reset operation sets back to defaults.
1258          */
1259         autoc = IXGBE_READ_REG(hw, IXGBE_AUTOC);
1260         autoc2 = IXGBE_READ_REG(hw, IXGBE_AUTOC2);
1261
1262         /* Enable link if disabled in NVM */
1263         if (autoc2 & IXGBE_AUTOC2_LINK_DISABLE_MASK) {
1264                 autoc2 &= ~IXGBE_AUTOC2_LINK_DISABLE_MASK;
1265                 IXGBE_WRITE_REG(hw, IXGBE_AUTOC2, autoc2);
1266                 IXGBE_WRITE_FLUSH(hw);
1267         }
1268
1269         if (hw->mac.orig_link_settings_stored == false) {
1270                 hw->mac.orig_autoc = autoc;
1271                 hw->mac.orig_autoc2 = autoc2;
1272                 hw->mac.orig_link_settings_stored = true;
1273         } else {
1274
1275                 /* If MNG FW is running on a multi-speed device that
1276                  * doesn't autoneg with out driver support we need to
1277                  * leave LMS in the state it was before we MAC reset.
1278                  * Likewise if we support WoL we don't want change the
1279                  * LMS state.
1280                  */
1281                 if ((hw->phy.multispeed_fiber && ixgbe_mng_enabled(hw)) ||
1282                     hw->wol_enabled)
1283                         hw->mac.orig_autoc =
1284                                 (hw->mac.orig_autoc & ~IXGBE_AUTOC_LMS_MASK) |
1285                                 curr_lms;
1286
1287                 if (autoc != hw->mac.orig_autoc) {
1288                         status = hw->mac.ops.prot_autoc_write(hw,
1289                                                         hw->mac.orig_autoc,
1290                                                         false);
1291                         if (status != IXGBE_SUCCESS)
1292                                 goto reset_hw_out;
1293                 }
1294
1295                 if ((autoc2 & IXGBE_AUTOC2_UPPER_MASK) !=
1296                     (hw->mac.orig_autoc2 & IXGBE_AUTOC2_UPPER_MASK)) {
1297                         autoc2 &= ~IXGBE_AUTOC2_UPPER_MASK;
1298                         autoc2 |= (hw->mac.orig_autoc2 &
1299                                    IXGBE_AUTOC2_UPPER_MASK);
1300                         IXGBE_WRITE_REG(hw, IXGBE_AUTOC2, autoc2);
1301                 }
1302         }
1303
1304         /* Store the permanent mac address */
1305         hw->mac.ops.get_mac_addr(hw, hw->mac.perm_addr);
1306
1307         /*
1308          * Store MAC address from RAR0, clear receive address registers, and
1309          * clear the multicast table.  Also reset num_rar_entries to 128,
1310          * since we modify this value when programming the SAN MAC address.
1311          */
1312         hw->mac.num_rar_entries = 128;
1313         hw->mac.ops.init_rx_addrs(hw);
1314
1315         /* Store the permanent SAN mac address */
1316         hw->mac.ops.get_san_mac_addr(hw, hw->mac.san_addr);
1317
1318         /* Add the SAN MAC address to the RAR only if it's a valid address */
1319         if (ixgbe_validate_mac_addr(hw->mac.san_addr) == 0) {
1320                 hw->mac.ops.set_rar(hw, hw->mac.num_rar_entries - 1,
1321                                     hw->mac.san_addr, 0, IXGBE_RAH_AV);
1322
1323                 /* Save the SAN MAC RAR index */
1324                 hw->mac.san_mac_rar_index = hw->mac.num_rar_entries - 1;
1325
1326                 /* Reserve the last RAR for the SAN MAC address */
1327                 hw->mac.num_rar_entries--;
1328         }
1329
1330         /* Store the alternative WWNN/WWPN prefix */
1331         hw->mac.ops.get_wwn_prefix(hw, &hw->mac.wwnn_prefix,
1332                                    &hw->mac.wwpn_prefix);
1333
1334 reset_hw_out:
1335         return status;
1336 }
1337
1338 /**
1339  * ixgbe_fdir_check_cmd_complete - poll to check whether FDIRCMD is complete
1340  * @hw: pointer to hardware structure
1341  */
1342 STATIC s32 ixgbe_fdir_check_cmd_complete(struct ixgbe_hw *hw)
1343 {
1344         int i;
1345
1346         for (i = 0; i < IXGBE_FDIRCMD_CMD_POLL; i++) {
1347                 if (!(IXGBE_READ_REG(hw, IXGBE_FDIRCMD) &
1348                       IXGBE_FDIRCMD_CMD_MASK))
1349                         return IXGBE_SUCCESS;
1350                 usec_delay(10);
1351         }
1352
1353         return IXGBE_ERR_FDIR_CMD_INCOMPLETE;
1354 }
1355
1356 /**
1357  *  ixgbe_reinit_fdir_tables_82599 - Reinitialize Flow Director tables.
1358  *  @hw: pointer to hardware structure
1359  **/
1360 s32 ixgbe_reinit_fdir_tables_82599(struct ixgbe_hw *hw)
1361 {
1362         s32 err;
1363         int i;
1364         u32 fdirctrl = IXGBE_READ_REG(hw, IXGBE_FDIRCTRL);
1365         fdirctrl &= ~IXGBE_FDIRCTRL_INIT_DONE;
1366
1367         DEBUGFUNC("ixgbe_reinit_fdir_tables_82599");
1368
1369         /*
1370          * Before starting reinitialization process,
1371          * FDIRCMD.CMD must be zero.
1372          */
1373         err = ixgbe_fdir_check_cmd_complete(hw);
1374         if (err) {
1375                 DEBUGOUT("Flow Director previous command did not complete, aborting table re-initialization.\n");
1376                 return err;
1377         }
1378
1379         IXGBE_WRITE_REG(hw, IXGBE_FDIRFREE, 0);
1380         IXGBE_WRITE_FLUSH(hw);
1381         /*
1382          * 82599 adapters flow director init flow cannot be restarted,
1383          * Workaround 82599 silicon errata by performing the following steps
1384          * before re-writing the FDIRCTRL control register with the same value.
1385          * - write 1 to bit 8 of FDIRCMD register &
1386          * - write 0 to bit 8 of FDIRCMD register
1387          */
1388         IXGBE_WRITE_REG(hw, IXGBE_FDIRCMD,
1389                         (IXGBE_READ_REG(hw, IXGBE_FDIRCMD) |
1390                          IXGBE_FDIRCMD_CLEARHT));
1391         IXGBE_WRITE_FLUSH(hw);
1392         IXGBE_WRITE_REG(hw, IXGBE_FDIRCMD,
1393                         (IXGBE_READ_REG(hw, IXGBE_FDIRCMD) &
1394                          ~IXGBE_FDIRCMD_CLEARHT));
1395         IXGBE_WRITE_FLUSH(hw);
1396         /*
1397          * Clear FDIR Hash register to clear any leftover hashes
1398          * waiting to be programmed.
1399          */
1400         IXGBE_WRITE_REG(hw, IXGBE_FDIRHASH, 0x00);
1401         IXGBE_WRITE_FLUSH(hw);
1402
1403         IXGBE_WRITE_REG(hw, IXGBE_FDIRCTRL, fdirctrl);
1404         IXGBE_WRITE_FLUSH(hw);
1405
1406         /* Poll init-done after we write FDIRCTRL register */
1407         for (i = 0; i < IXGBE_FDIR_INIT_DONE_POLL; i++) {
1408                 if (IXGBE_READ_REG(hw, IXGBE_FDIRCTRL) &
1409                                    IXGBE_FDIRCTRL_INIT_DONE)
1410                         break;
1411                 msec_delay(1);
1412         }
1413         if (i >= IXGBE_FDIR_INIT_DONE_POLL) {
1414                 DEBUGOUT("Flow Director Signature poll time exceeded!\n");
1415                 return IXGBE_ERR_FDIR_REINIT_FAILED;
1416         }
1417
1418         /* Clear FDIR statistics registers (read to clear) */
1419         IXGBE_READ_REG(hw, IXGBE_FDIRUSTAT);
1420         IXGBE_READ_REG(hw, IXGBE_FDIRFSTAT);
1421         IXGBE_READ_REG(hw, IXGBE_FDIRMATCH);
1422         IXGBE_READ_REG(hw, IXGBE_FDIRMISS);
1423         IXGBE_READ_REG(hw, IXGBE_FDIRLEN);
1424
1425         return IXGBE_SUCCESS;
1426 }
1427
1428 /**
1429  *  ixgbe_fdir_enable_82599 - Initialize Flow Director control registers
1430  *  @hw: pointer to hardware structure
1431  *  @fdirctrl: value to write to flow director control register
1432  **/
1433 STATIC void ixgbe_fdir_enable_82599(struct ixgbe_hw *hw, u32 fdirctrl)
1434 {
1435         int i;
1436
1437         DEBUGFUNC("ixgbe_fdir_enable_82599");
1438
1439         /* Prime the keys for hashing */
1440         IXGBE_WRITE_REG(hw, IXGBE_FDIRHKEY, IXGBE_ATR_BUCKET_HASH_KEY);
1441         IXGBE_WRITE_REG(hw, IXGBE_FDIRSKEY, IXGBE_ATR_SIGNATURE_HASH_KEY);
1442
1443         /*
1444          * Poll init-done after we write the register.  Estimated times:
1445          *      10G: PBALLOC = 11b, timing is 60us
1446          *       1G: PBALLOC = 11b, timing is 600us
1447          *     100M: PBALLOC = 11b, timing is 6ms
1448          *
1449          *     Multiple these timings by 4 if under full Rx load
1450          *
1451          * So we'll poll for IXGBE_FDIR_INIT_DONE_POLL times, sleeping for
1452          * 1 msec per poll time.  If we're at line rate and drop to 100M, then
1453          * this might not finish in our poll time, but we can live with that
1454          * for now.
1455          */
1456         IXGBE_WRITE_REG(hw, IXGBE_FDIRCTRL, fdirctrl);
1457         IXGBE_WRITE_FLUSH(hw);
1458         for (i = 0; i < IXGBE_FDIR_INIT_DONE_POLL; i++) {
1459                 if (IXGBE_READ_REG(hw, IXGBE_FDIRCTRL) &
1460                                    IXGBE_FDIRCTRL_INIT_DONE)
1461                         break;
1462                 msec_delay(1);
1463         }
1464
1465         if (i >= IXGBE_FDIR_INIT_DONE_POLL)
1466                 DEBUGOUT("Flow Director poll time exceeded!\n");
1467 }
1468
1469 /**
1470  *  ixgbe_init_fdir_signature_82599 - Initialize Flow Director signature filters
1471  *  @hw: pointer to hardware structure
1472  *  @fdirctrl: value to write to flow director control register, initially
1473  *           contains just the value of the Rx packet buffer allocation
1474  **/
1475 s32 ixgbe_init_fdir_signature_82599(struct ixgbe_hw *hw, u32 fdirctrl)
1476 {
1477         DEBUGFUNC("ixgbe_init_fdir_signature_82599");
1478
1479         /*
1480          * Continue setup of fdirctrl register bits:
1481          *  Move the flexible bytes to use the ethertype - shift 6 words
1482          *  Set the maximum length per hash bucket to 0xA filters
1483          *  Send interrupt when 64 filters are left
1484          */
1485         fdirctrl |= (0x6 << IXGBE_FDIRCTRL_FLEX_SHIFT) |
1486                     (0xA << IXGBE_FDIRCTRL_MAX_LENGTH_SHIFT) |
1487                     (4 << IXGBE_FDIRCTRL_FULL_THRESH_SHIFT);
1488
1489         /* write hashes and fdirctrl register, poll for completion */
1490         ixgbe_fdir_enable_82599(hw, fdirctrl);
1491
1492         return IXGBE_SUCCESS;
1493 }
1494
1495 /**
1496  *  ixgbe_init_fdir_perfect_82599 - Initialize Flow Director perfect filters
1497  *  @hw: pointer to hardware structure
1498  *  @fdirctrl: value to write to flow director control register, initially
1499  *           contains just the value of the Rx packet buffer allocation
1500  *  @cloud_mode: true - cloud mode, false - other mode
1501  **/
1502 s32 ixgbe_init_fdir_perfect_82599(struct ixgbe_hw *hw, u32 fdirctrl,
1503                         bool cloud_mode)
1504 {
1505         DEBUGFUNC("ixgbe_init_fdir_perfect_82599");
1506
1507         /*
1508          * Continue setup of fdirctrl register bits:
1509          *  Turn perfect match filtering on
1510          *  Report hash in RSS field of Rx wb descriptor
1511          *  Initialize the drop queue
1512          *  Move the flexible bytes to use the ethertype - shift 6 words
1513          *  Set the maximum length per hash bucket to 0xA filters
1514          *  Send interrupt when 64 (0x4 * 16) filters are left
1515          */
1516         fdirctrl |= IXGBE_FDIRCTRL_PERFECT_MATCH |
1517                     IXGBE_FDIRCTRL_REPORT_STATUS |
1518                     (IXGBE_FDIR_DROP_QUEUE << IXGBE_FDIRCTRL_DROP_Q_SHIFT) |
1519                     (0x6 << IXGBE_FDIRCTRL_FLEX_SHIFT) |
1520                     (0xA << IXGBE_FDIRCTRL_MAX_LENGTH_SHIFT) |
1521                     (4 << IXGBE_FDIRCTRL_FULL_THRESH_SHIFT);
1522
1523         if (cloud_mode)
1524                 fdirctrl |=(IXGBE_FDIRCTRL_FILTERMODE_CLOUD <<
1525                                         IXGBE_FDIRCTRL_FILTERMODE_SHIFT);
1526
1527         /* write hashes and fdirctrl register, poll for completion */
1528         ixgbe_fdir_enable_82599(hw, fdirctrl);
1529
1530         return IXGBE_SUCCESS;
1531 }
1532
1533 /*
1534  * These defines allow us to quickly generate all of the necessary instructions
1535  * in the function below by simply calling out IXGBE_COMPUTE_SIG_HASH_ITERATION
1536  * for values 0 through 15
1537  */
1538 #define IXGBE_ATR_COMMON_HASH_KEY \
1539                 (IXGBE_ATR_BUCKET_HASH_KEY & IXGBE_ATR_SIGNATURE_HASH_KEY)
1540 #define IXGBE_COMPUTE_SIG_HASH_ITERATION(_n) \
1541 do { \
1542         u32 n = (_n); \
1543         if (IXGBE_ATR_COMMON_HASH_KEY & (0x01 << n)) \
1544                 common_hash ^= lo_hash_dword >> n; \
1545         else if (IXGBE_ATR_BUCKET_HASH_KEY & (0x01 << n)) \
1546                 bucket_hash ^= lo_hash_dword >> n; \
1547         else if (IXGBE_ATR_SIGNATURE_HASH_KEY & (0x01 << n)) \
1548                 sig_hash ^= lo_hash_dword << (16 - n); \
1549         if (IXGBE_ATR_COMMON_HASH_KEY & (0x01 << (n + 16))) \
1550                 common_hash ^= hi_hash_dword >> n; \
1551         else if (IXGBE_ATR_BUCKET_HASH_KEY & (0x01 << (n + 16))) \
1552                 bucket_hash ^= hi_hash_dword >> n; \
1553         else if (IXGBE_ATR_SIGNATURE_HASH_KEY & (0x01 << (n + 16))) \
1554                 sig_hash ^= hi_hash_dword << (16 - n); \
1555 } while (0)
1556
1557 /**
1558  *  ixgbe_atr_compute_sig_hash_82599 - Compute the signature hash
1559  *  @stream: input bitstream to compute the hash on
1560  *
1561  *  This function is almost identical to the function above but contains
1562  *  several optimizations such as unwinding all of the loops, letting the
1563  *  compiler work out all of the conditional ifs since the keys are static
1564  *  defines, and computing two keys at once since the hashed dword stream
1565  *  will be the same for both keys.
1566  **/
1567 u32 ixgbe_atr_compute_sig_hash_82599(union ixgbe_atr_hash_dword input,
1568                                      union ixgbe_atr_hash_dword common)
1569 {
1570         u32 hi_hash_dword, lo_hash_dword, flow_vm_vlan;
1571         u32 sig_hash = 0, bucket_hash = 0, common_hash = 0;
1572
1573         /* record the flow_vm_vlan bits as they are a key part to the hash */
1574         flow_vm_vlan = IXGBE_NTOHL(input.dword);
1575
1576         /* generate common hash dword */
1577         hi_hash_dword = IXGBE_NTOHL(common.dword);
1578
1579         /* low dword is word swapped version of common */
1580         lo_hash_dword = (hi_hash_dword >> 16) | (hi_hash_dword << 16);
1581
1582         /* apply flow ID/VM pool/VLAN ID bits to hash words */
1583         hi_hash_dword ^= flow_vm_vlan ^ (flow_vm_vlan >> 16);
1584
1585         /* Process bits 0 and 16 */
1586         IXGBE_COMPUTE_SIG_HASH_ITERATION(0);
1587
1588         /*
1589          * apply flow ID/VM pool/VLAN ID bits to lo hash dword, we had to
1590          * delay this because bit 0 of the stream should not be processed
1591          * so we do not add the VLAN until after bit 0 was processed
1592          */
1593         lo_hash_dword ^= flow_vm_vlan ^ (flow_vm_vlan << 16);
1594
1595         /* Process remaining 30 bit of the key */
1596         IXGBE_COMPUTE_SIG_HASH_ITERATION(1);
1597         IXGBE_COMPUTE_SIG_HASH_ITERATION(2);
1598         IXGBE_COMPUTE_SIG_HASH_ITERATION(3);
1599         IXGBE_COMPUTE_SIG_HASH_ITERATION(4);
1600         IXGBE_COMPUTE_SIG_HASH_ITERATION(5);
1601         IXGBE_COMPUTE_SIG_HASH_ITERATION(6);
1602         IXGBE_COMPUTE_SIG_HASH_ITERATION(7);
1603         IXGBE_COMPUTE_SIG_HASH_ITERATION(8);
1604         IXGBE_COMPUTE_SIG_HASH_ITERATION(9);
1605         IXGBE_COMPUTE_SIG_HASH_ITERATION(10);
1606         IXGBE_COMPUTE_SIG_HASH_ITERATION(11);
1607         IXGBE_COMPUTE_SIG_HASH_ITERATION(12);
1608         IXGBE_COMPUTE_SIG_HASH_ITERATION(13);
1609         IXGBE_COMPUTE_SIG_HASH_ITERATION(14);
1610         IXGBE_COMPUTE_SIG_HASH_ITERATION(15);
1611
1612         /* combine common_hash result with signature and bucket hashes */
1613         bucket_hash ^= common_hash;
1614         bucket_hash &= IXGBE_ATR_HASH_MASK;
1615
1616         sig_hash ^= common_hash << 16;
1617         sig_hash &= IXGBE_ATR_HASH_MASK << 16;
1618
1619         /* return completed signature hash */
1620         return sig_hash ^ bucket_hash;
1621 }
1622
1623 /**
1624  *  ixgbe_atr_add_signature_filter_82599 - Adds a signature hash filter
1625  *  @hw: pointer to hardware structure
1626  *  @input: unique input dword
1627  *  @common: compressed common input dword
1628  *  @queue: queue index to direct traffic to
1629  **/
1630 s32 ixgbe_fdir_add_signature_filter_82599(struct ixgbe_hw *hw,
1631                                           union ixgbe_atr_hash_dword input,
1632                                           union ixgbe_atr_hash_dword common,
1633                                           u8 queue)
1634 {
1635         u64 fdirhashcmd;
1636         u32 fdircmd;
1637         s32 err;
1638
1639         DEBUGFUNC("ixgbe_fdir_add_signature_filter_82599");
1640
1641         /*
1642          * Get the flow_type in order to program FDIRCMD properly
1643          * lowest 2 bits are FDIRCMD.L4TYPE, third lowest bit is FDIRCMD.IPV6
1644          * fifth is FDIRCMD.TUNNEL_FILTER
1645          */
1646         switch (input.formatted.flow_type) {
1647         case IXGBE_ATR_FLOW_TYPE_TCPV4:
1648         case IXGBE_ATR_FLOW_TYPE_UDPV4:
1649         case IXGBE_ATR_FLOW_TYPE_SCTPV4:
1650         case IXGBE_ATR_FLOW_TYPE_TCPV6:
1651         case IXGBE_ATR_FLOW_TYPE_UDPV6:
1652         case IXGBE_ATR_FLOW_TYPE_SCTPV6:
1653                 break;
1654         default:
1655                 DEBUGOUT(" Error on flow type input\n");
1656                 return IXGBE_ERR_CONFIG;
1657         }
1658
1659         /* configure FDIRCMD register */
1660         fdircmd = IXGBE_FDIRCMD_CMD_ADD_FLOW | IXGBE_FDIRCMD_FILTER_UPDATE |
1661                   IXGBE_FDIRCMD_LAST | IXGBE_FDIRCMD_QUEUE_EN;
1662         fdircmd |= input.formatted.flow_type << IXGBE_FDIRCMD_FLOW_TYPE_SHIFT;
1663         fdircmd |= (u32)queue << IXGBE_FDIRCMD_RX_QUEUE_SHIFT;
1664
1665         /*
1666          * The lower 32-bits of fdirhashcmd is for FDIRHASH, the upper 32-bits
1667          * is for FDIRCMD.  Then do a 64-bit register write from FDIRHASH.
1668          */
1669         fdirhashcmd = (u64)fdircmd << 32;
1670         fdirhashcmd |= ixgbe_atr_compute_sig_hash_82599(input, common);
1671         IXGBE_WRITE_REG64(hw, IXGBE_FDIRHASH, fdirhashcmd);
1672
1673         err = ixgbe_fdir_check_cmd_complete(hw);
1674         if (err) {
1675                 DEBUGOUT("Flow Director command did not complete!\n");
1676                 return err;
1677         }
1678
1679         DEBUGOUT2("Tx Queue=%x hash=%x\n", queue, (u32)fdirhashcmd);
1680
1681         return IXGBE_SUCCESS;
1682 }
1683
1684 #define IXGBE_COMPUTE_BKT_HASH_ITERATION(_n) \
1685 do { \
1686         u32 n = (_n); \
1687         if (IXGBE_ATR_BUCKET_HASH_KEY & (0x01 << n)) \
1688                 bucket_hash ^= lo_hash_dword >> n; \
1689         if (IXGBE_ATR_BUCKET_HASH_KEY & (0x01 << (n + 16))) \
1690                 bucket_hash ^= hi_hash_dword >> n; \
1691 } while (0)
1692
1693 /**
1694  *  ixgbe_atr_compute_perfect_hash_82599 - Compute the perfect filter hash
1695  *  @atr_input: input bitstream to compute the hash on
1696  *  @input_mask: mask for the input bitstream
1697  *
1698  *  This function serves two main purposes.  First it applies the input_mask
1699  *  to the atr_input resulting in a cleaned up atr_input data stream.
1700  *  Secondly it computes the hash and stores it in the bkt_hash field at
1701  *  the end of the input byte stream.  This way it will be available for
1702  *  future use without needing to recompute the hash.
1703  **/
1704 void ixgbe_atr_compute_perfect_hash_82599(union ixgbe_atr_input *input,
1705                                           union ixgbe_atr_input *input_mask)
1706 {
1707
1708         u32 hi_hash_dword, lo_hash_dword, flow_vm_vlan;
1709         u32 bucket_hash = 0;
1710         u32 hi_dword = 0;
1711         u32 i = 0;
1712
1713         /* Apply masks to input data */
1714         for (i = 0; i < 14; i++)
1715                 input->dword_stream[i]  &= input_mask->dword_stream[i];
1716
1717         /* record the flow_vm_vlan bits as they are a key part to the hash */
1718         flow_vm_vlan = IXGBE_NTOHL(input->dword_stream[0]);
1719
1720         /* generate common hash dword */
1721         for (i = 1; i <= 13; i++)
1722                 hi_dword ^= input->dword_stream[i];
1723         hi_hash_dword = IXGBE_NTOHL(hi_dword);
1724
1725         /* low dword is word swapped version of common */
1726         lo_hash_dword = (hi_hash_dword >> 16) | (hi_hash_dword << 16);
1727
1728         /* apply flow ID/VM pool/VLAN ID bits to hash words */
1729         hi_hash_dword ^= flow_vm_vlan ^ (flow_vm_vlan >> 16);
1730
1731         /* Process bits 0 and 16 */
1732         IXGBE_COMPUTE_BKT_HASH_ITERATION(0);
1733
1734         /*
1735          * apply flow ID/VM pool/VLAN ID bits to lo hash dword, we had to
1736          * delay this because bit 0 of the stream should not be processed
1737          * so we do not add the VLAN until after bit 0 was processed
1738          */
1739         lo_hash_dword ^= flow_vm_vlan ^ (flow_vm_vlan << 16);
1740
1741         /* Process remaining 30 bit of the key */
1742         for (i = 1; i <= 15; i++)
1743                 IXGBE_COMPUTE_BKT_HASH_ITERATION(i);
1744
1745         /*
1746          * Limit hash to 13 bits since max bucket count is 8K.
1747          * Store result at the end of the input stream.
1748          */
1749         input->formatted.bkt_hash = bucket_hash & 0x1FFF;
1750 }
1751
1752 /**
1753  *  ixgbe_get_fdirtcpm_82599 - generate a TCP port from atr_input_masks
1754  *  @input_mask: mask to be bit swapped
1755  *
1756  *  The source and destination port masks for flow director are bit swapped
1757  *  in that bit 15 effects bit 0, 14 effects 1, 13, 2 etc.  In order to
1758  *  generate a correctly swapped value we need to bit swap the mask and that
1759  *  is what is accomplished by this function.
1760  **/
1761 STATIC u32 ixgbe_get_fdirtcpm_82599(union ixgbe_atr_input *input_mask)
1762 {
1763         u32 mask = IXGBE_NTOHS(input_mask->formatted.dst_port);
1764         mask <<= IXGBE_FDIRTCPM_DPORTM_SHIFT;
1765         mask |= IXGBE_NTOHS(input_mask->formatted.src_port);
1766         mask = ((mask & 0x55555555) << 1) | ((mask & 0xAAAAAAAA) >> 1);
1767         mask = ((mask & 0x33333333) << 2) | ((mask & 0xCCCCCCCC) >> 2);
1768         mask = ((mask & 0x0F0F0F0F) << 4) | ((mask & 0xF0F0F0F0) >> 4);
1769         return ((mask & 0x00FF00FF) << 8) | ((mask & 0xFF00FF00) >> 8);
1770 }
1771
1772 /*
1773  * These two macros are meant to address the fact that we have registers
1774  * that are either all or in part big-endian.  As a result on big-endian
1775  * systems we will end up byte swapping the value to little-endian before
1776  * it is byte swapped again and written to the hardware in the original
1777  * big-endian format.
1778  */
1779 #define IXGBE_STORE_AS_BE32(_value) \
1780         (((u32)(_value) >> 24) | (((u32)(_value) & 0x00FF0000) >> 8) | \
1781          (((u32)(_value) & 0x0000FF00) << 8) | ((u32)(_value) << 24))
1782
1783 #define IXGBE_WRITE_REG_BE32(a, reg, value) \
1784         IXGBE_WRITE_REG((a), (reg), IXGBE_STORE_AS_BE32(IXGBE_NTOHL(value)))
1785
1786 #define IXGBE_STORE_AS_BE16(_value) \
1787         IXGBE_NTOHS(((u16)(_value) >> 8) | ((u16)(_value) << 8))
1788
1789 s32 ixgbe_fdir_set_input_mask_82599(struct ixgbe_hw *hw,
1790                                     union ixgbe_atr_input *input_mask, bool cloud_mode)
1791 {
1792         /* mask IPv6 since it is currently not supported */
1793         u32 fdirm = IXGBE_FDIRM_DIPv6;
1794         u32 fdirtcpm;
1795         u32 fdirip6m;
1796         DEBUGFUNC("ixgbe_fdir_set_atr_input_mask_82599");
1797
1798         /*
1799          * Program the relevant mask registers.  If src/dst_port or src/dst_addr
1800          * are zero, then assume a full mask for that field.  Also assume that
1801          * a VLAN of 0 is unspecified, so mask that out as well.  L4type
1802          * cannot be masked out in this implementation.
1803          *
1804          * This also assumes IPv4 only.  IPv6 masking isn't supported at this
1805          * point in time.
1806          */
1807
1808         /* verify bucket hash is cleared on hash generation */
1809         if (input_mask->formatted.bkt_hash)
1810                 DEBUGOUT(" bucket hash should always be 0 in mask\n");
1811
1812         /* Program FDIRM and verify partial masks */
1813         switch (input_mask->formatted.vm_pool & 0x7F) {
1814         case 0x0:
1815                 fdirm |= IXGBE_FDIRM_POOL;
1816         case 0x7F:
1817                 break;
1818         default:
1819                 DEBUGOUT(" Error on vm pool mask\n");
1820                 return IXGBE_ERR_CONFIG;
1821         }
1822
1823         switch (input_mask->formatted.flow_type & IXGBE_ATR_L4TYPE_MASK) {
1824         case 0x0:
1825                 fdirm |= IXGBE_FDIRM_L4P;
1826                 if (input_mask->formatted.dst_port ||
1827                     input_mask->formatted.src_port) {
1828                         DEBUGOUT(" Error on src/dst port mask\n");
1829                         return IXGBE_ERR_CONFIG;
1830                 }
1831         case IXGBE_ATR_L4TYPE_MASK:
1832                 break;
1833         default:
1834                 DEBUGOUT(" Error on flow type mask\n");
1835                 return IXGBE_ERR_CONFIG;
1836         }
1837
1838         switch (IXGBE_NTOHS(input_mask->formatted.vlan_id) & 0xEFFF) {
1839         case 0x0000:
1840                 /* mask VLAN ID, fall through to mask VLAN priority */
1841                 fdirm |= IXGBE_FDIRM_VLANID;
1842         case 0x0FFF:
1843                 /* mask VLAN priority */
1844                 fdirm |= IXGBE_FDIRM_VLANP;
1845                 break;
1846         case 0xE000:
1847                 /* mask VLAN ID only, fall through */
1848                 fdirm |= IXGBE_FDIRM_VLANID;
1849         case 0xEFFF:
1850                 /* no VLAN fields masked */
1851                 break;
1852         default:
1853                 DEBUGOUT(" Error on VLAN mask\n");
1854                 return IXGBE_ERR_CONFIG;
1855         }
1856
1857         switch (input_mask->formatted.flex_bytes & 0xFFFF) {
1858         case 0x0000:
1859                 /* Mask Flex Bytes, fall through */
1860                 fdirm |= IXGBE_FDIRM_FLEX;
1861         case 0xFFFF:
1862                 break;
1863         default:
1864                 DEBUGOUT(" Error on flexible byte mask\n");
1865                 return IXGBE_ERR_CONFIG;
1866         }
1867
1868         if (cloud_mode) {
1869                 fdirm |= IXGBE_FDIRM_L3P;
1870                 fdirip6m = ((u32) 0xFFFFU << IXGBE_FDIRIP6M_DIPM_SHIFT);
1871                 fdirip6m |= IXGBE_FDIRIP6M_ALWAYS_MASK;
1872
1873                 switch (input_mask->formatted.inner_mac[0] & 0xFF) {
1874                 case 0x00:
1875                         /* Mask inner MAC, fall through */
1876                         fdirip6m |= IXGBE_FDIRIP6M_INNER_MAC;
1877                 case 0xFF:
1878                         break;
1879                 default:
1880                         DEBUGOUT(" Error on inner_mac byte mask\n");
1881                         return IXGBE_ERR_CONFIG;
1882                 }
1883
1884                 switch (input_mask->formatted.tni_vni & 0xFFFFFFFF) {
1885                 case 0x0:
1886                         /* Mask vxlan id */
1887                         fdirip6m |= IXGBE_FDIRIP6M_TNI_VNI;
1888                         break;
1889                 case 0x00FFFFFF:
1890                         fdirip6m |= IXGBE_FDIRIP6M_TNI_VNI_24;
1891                         break;
1892                 case 0xFFFFFFFF:
1893                         break;
1894                 default:
1895                         DEBUGOUT(" Error on TNI/VNI byte mask\n");
1896                         return IXGBE_ERR_CONFIG;
1897                 }
1898
1899                 switch (input_mask->formatted.tunnel_type & 0xFFFF) {
1900                 case 0x0:
1901                         /* Mask turnnel type, fall through */
1902                         fdirip6m |= IXGBE_FDIRIP6M_TUNNEL_TYPE;
1903                 case 0xFFFF:
1904                         break;
1905                 default:
1906                         DEBUGOUT(" Error on tunnel type byte mask\n");
1907                         return IXGBE_ERR_CONFIG;
1908                 }
1909                 IXGBE_WRITE_REG_BE32(hw, IXGBE_FDIRIP6M, fdirip6m);
1910         }
1911
1912         /* Now mask VM pool and destination IPv6 - bits 5 and 2 */
1913         IXGBE_WRITE_REG(hw, IXGBE_FDIRM, fdirm);
1914
1915         /* store the TCP/UDP port masks, bit reversed from port layout */
1916         fdirtcpm = ixgbe_get_fdirtcpm_82599(input_mask);
1917
1918         /* write both the same so that UDP and TCP use the same mask */
1919         IXGBE_WRITE_REG(hw, IXGBE_FDIRTCPM, ~fdirtcpm);
1920         IXGBE_WRITE_REG(hw, IXGBE_FDIRUDPM, ~fdirtcpm);
1921
1922         /* store source and destination IP masks (big-endian) */
1923         IXGBE_WRITE_REG_BE32(hw, IXGBE_FDIRSIP4M,
1924                              ~input_mask->formatted.src_ip[0]);
1925         IXGBE_WRITE_REG_BE32(hw, IXGBE_FDIRDIP4M,
1926                              ~input_mask->formatted.dst_ip[0]);
1927
1928         return IXGBE_SUCCESS;
1929 }
1930
1931 s32 ixgbe_fdir_write_perfect_filter_82599(struct ixgbe_hw *hw,
1932                                           union ixgbe_atr_input *input,
1933                                           u16 soft_id, u8 queue, bool cloud_mode)
1934 {
1935         u32 fdirport, fdirvlan, fdirhash, fdircmd;
1936         u32 addr_low, addr_high;
1937         u32 cloud_type = 0;
1938         s32 err;
1939
1940         DEBUGFUNC("ixgbe_fdir_write_perfect_filter_82599");
1941
1942         /* currently IPv6 is not supported, must be programmed with 0 */
1943         IXGBE_WRITE_REG_BE32(hw, IXGBE_FDIRSIPv6(0),
1944                              input->formatted.src_ip[0]);
1945         IXGBE_WRITE_REG_BE32(hw, IXGBE_FDIRSIPv6(1),
1946                              input->formatted.src_ip[1]);
1947         IXGBE_WRITE_REG_BE32(hw, IXGBE_FDIRSIPv6(2),
1948                              input->formatted.src_ip[2]);
1949
1950         /* record the source address (big-endian) */
1951         IXGBE_WRITE_REG_BE32(hw, IXGBE_FDIRIPSA, input->formatted.src_ip[0]);
1952
1953         /* record the first 32 bits of the destination address (big-endian) */
1954         IXGBE_WRITE_REG_BE32(hw, IXGBE_FDIRIPDA, input->formatted.dst_ip[0]);
1955
1956         /* record source and destination port (little-endian)*/
1957         fdirport = IXGBE_NTOHS(input->formatted.dst_port);
1958         fdirport <<= IXGBE_FDIRPORT_DESTINATION_SHIFT;
1959         fdirport |= IXGBE_NTOHS(input->formatted.src_port);
1960         IXGBE_WRITE_REG(hw, IXGBE_FDIRPORT, fdirport);
1961
1962         /* record VLAN (little-endian) and flex_bytes(big-endian) */
1963         fdirvlan = IXGBE_STORE_AS_BE16(input->formatted.flex_bytes);
1964         fdirvlan <<= IXGBE_FDIRVLAN_FLEX_SHIFT;
1965         fdirvlan |= IXGBE_NTOHS(input->formatted.vlan_id);
1966         IXGBE_WRITE_REG(hw, IXGBE_FDIRVLAN, fdirvlan);
1967
1968         if (cloud_mode) {
1969                 if (input->formatted.tunnel_type != 0)
1970                         cloud_type = 0x80000000;
1971
1972                 addr_low = ((u32)input->formatted.inner_mac[0] |
1973                                 ((u32)input->formatted.inner_mac[1] << 8) |
1974                                 ((u32)input->formatted.inner_mac[2] << 16) |
1975                                 ((u32)input->formatted.inner_mac[3] << 24));
1976                 addr_high = ((u32)input->formatted.inner_mac[4] |
1977                                 ((u32)input->formatted.inner_mac[5] << 8));
1978                 cloud_type |= addr_high;
1979                 IXGBE_WRITE_REG_BE32(hw, IXGBE_FDIRSIPv6(0), addr_low);
1980                 IXGBE_WRITE_REG_BE32(hw, IXGBE_FDIRSIPv6(1), cloud_type);
1981                 IXGBE_WRITE_REG_BE32(hw, IXGBE_FDIRSIPv6(2), input->formatted.tni_vni);
1982         }
1983
1984         /* configure FDIRHASH register */
1985         fdirhash = input->formatted.bkt_hash;
1986         fdirhash |= soft_id << IXGBE_FDIRHASH_SIG_SW_INDEX_SHIFT;
1987         IXGBE_WRITE_REG(hw, IXGBE_FDIRHASH, fdirhash);
1988
1989         /*
1990          * flush all previous writes to make certain registers are
1991          * programmed prior to issuing the command
1992          */
1993         IXGBE_WRITE_FLUSH(hw);
1994
1995         /* configure FDIRCMD register */
1996         fdircmd = IXGBE_FDIRCMD_CMD_ADD_FLOW | IXGBE_FDIRCMD_FILTER_UPDATE |
1997                   IXGBE_FDIRCMD_LAST | IXGBE_FDIRCMD_QUEUE_EN;
1998         if (queue == IXGBE_FDIR_DROP_QUEUE)
1999                 fdircmd |= IXGBE_FDIRCMD_DROP;
2000         if (input->formatted.flow_type & IXGBE_ATR_L4TYPE_TUNNEL_MASK)
2001                 fdircmd |= IXGBE_FDIRCMD_TUNNEL_FILTER;
2002         fdircmd |= input->formatted.flow_type << IXGBE_FDIRCMD_FLOW_TYPE_SHIFT;
2003         fdircmd |= (u32)queue << IXGBE_FDIRCMD_RX_QUEUE_SHIFT;
2004         fdircmd |= (u32)input->formatted.vm_pool << IXGBE_FDIRCMD_VT_POOL_SHIFT;
2005
2006         IXGBE_WRITE_REG(hw, IXGBE_FDIRCMD, fdircmd);
2007         err = ixgbe_fdir_check_cmd_complete(hw);
2008         if (err) {
2009                 DEBUGOUT("Flow Director command did not complete!\n");
2010                 return err;
2011         }
2012
2013         return IXGBE_SUCCESS;
2014 }
2015
2016 s32 ixgbe_fdir_erase_perfect_filter_82599(struct ixgbe_hw *hw,
2017                                           union ixgbe_atr_input *input,
2018                                           u16 soft_id)
2019 {
2020         u32 fdirhash;
2021         u32 fdircmd = 0;
2022         s32 err;
2023
2024         /* configure FDIRHASH register */
2025         fdirhash = input->formatted.bkt_hash;
2026         fdirhash |= soft_id << IXGBE_FDIRHASH_SIG_SW_INDEX_SHIFT;
2027         IXGBE_WRITE_REG(hw, IXGBE_FDIRHASH, fdirhash);
2028
2029         /* flush hash to HW */
2030         IXGBE_WRITE_FLUSH(hw);
2031
2032         /* Query if filter is present */
2033         IXGBE_WRITE_REG(hw, IXGBE_FDIRCMD, IXGBE_FDIRCMD_CMD_QUERY_REM_FILT);
2034
2035         err = ixgbe_fdir_check_cmd_complete(hw);
2036         if (err) {
2037                 DEBUGOUT("Flow Director command did not complete!\n");
2038                 return err;
2039         }
2040
2041         /* if filter exists in hardware then remove it */
2042         if (fdircmd & IXGBE_FDIRCMD_FILTER_VALID) {
2043                 IXGBE_WRITE_REG(hw, IXGBE_FDIRHASH, fdirhash);
2044                 IXGBE_WRITE_FLUSH(hw);
2045                 IXGBE_WRITE_REG(hw, IXGBE_FDIRCMD,
2046                                 IXGBE_FDIRCMD_CMD_REMOVE_FLOW);
2047         }
2048
2049         return IXGBE_SUCCESS;
2050 }
2051
2052 /**
2053  *  ixgbe_fdir_add_perfect_filter_82599 - Adds a perfect filter
2054  *  @hw: pointer to hardware structure
2055  *  @input: input bitstream
2056  *  @input_mask: mask for the input bitstream
2057  *  @soft_id: software index for the filters
2058  *  @queue: queue index to direct traffic to
2059  *
2060  *  Note that the caller to this function must lock before calling, since the
2061  *  hardware writes must be protected from one another.
2062  **/
2063 s32 ixgbe_fdir_add_perfect_filter_82599(struct ixgbe_hw *hw,
2064                                         union ixgbe_atr_input *input,
2065                                         union ixgbe_atr_input *input_mask,
2066                                         u16 soft_id, u8 queue, bool cloud_mode)
2067 {
2068         s32 err = IXGBE_ERR_CONFIG;
2069
2070         DEBUGFUNC("ixgbe_fdir_add_perfect_filter_82599");
2071
2072         /*
2073          * Check flow_type formatting, and bail out before we touch the hardware
2074          * if there's a configuration issue
2075          */
2076         switch (input->formatted.flow_type) {
2077         case IXGBE_ATR_FLOW_TYPE_IPV4:
2078         case IXGBE_ATR_FLOW_TYPE_TUNNELED_IPV4:
2079                 input_mask->formatted.flow_type = IXGBE_ATR_L4TYPE_IPV6_MASK;
2080                 if (input->formatted.dst_port || input->formatted.src_port) {
2081                         DEBUGOUT(" Error on src/dst port\n");
2082                         return IXGBE_ERR_CONFIG;
2083                 }
2084                 break;
2085         case IXGBE_ATR_FLOW_TYPE_SCTPV4:
2086         case IXGBE_ATR_FLOW_TYPE_TUNNELED_SCTPV4:
2087                 if (input->formatted.dst_port || input->formatted.src_port) {
2088                         DEBUGOUT(" Error on src/dst port\n");
2089                         return IXGBE_ERR_CONFIG;
2090                 }
2091         case IXGBE_ATR_FLOW_TYPE_TCPV4:
2092         case IXGBE_ATR_FLOW_TYPE_TUNNELED_TCPV4:
2093         case IXGBE_ATR_FLOW_TYPE_UDPV4:
2094         case IXGBE_ATR_FLOW_TYPE_TUNNELED_UDPV4:
2095                 input_mask->formatted.flow_type = IXGBE_ATR_L4TYPE_IPV6_MASK |
2096                                                   IXGBE_ATR_L4TYPE_MASK;
2097                 break;
2098         default:
2099                 DEBUGOUT(" Error on flow type input\n");
2100                 return err;
2101         }
2102
2103         /* program input mask into the HW */
2104         err = ixgbe_fdir_set_input_mask_82599(hw, input_mask, cloud_mode);
2105         if (err)
2106                 return err;
2107
2108         /* apply mask and compute/store hash */
2109         ixgbe_atr_compute_perfect_hash_82599(input, input_mask);
2110
2111         /* program filters to filter memory */
2112         return ixgbe_fdir_write_perfect_filter_82599(hw, input,
2113                                                      soft_id, queue, cloud_mode);
2114 }
2115
2116 /**
2117  *  ixgbe_read_analog_reg8_82599 - Reads 8 bit Omer analog register
2118  *  @hw: pointer to hardware structure
2119  *  @reg: analog register to read
2120  *  @val: read value
2121  *
2122  *  Performs read operation to Omer analog register specified.
2123  **/
2124 s32 ixgbe_read_analog_reg8_82599(struct ixgbe_hw *hw, u32 reg, u8 *val)
2125 {
2126         u32  core_ctl;
2127
2128         DEBUGFUNC("ixgbe_read_analog_reg8_82599");
2129
2130         IXGBE_WRITE_REG(hw, IXGBE_CORECTL, IXGBE_CORECTL_WRITE_CMD |
2131                         (reg << 8));
2132         IXGBE_WRITE_FLUSH(hw);
2133         usec_delay(10);
2134         core_ctl = IXGBE_READ_REG(hw, IXGBE_CORECTL);
2135         *val = (u8)core_ctl;
2136
2137         return IXGBE_SUCCESS;
2138 }
2139
2140 /**
2141  *  ixgbe_write_analog_reg8_82599 - Writes 8 bit Omer analog register
2142  *  @hw: pointer to hardware structure
2143  *  @reg: atlas register to write
2144  *  @val: value to write
2145  *
2146  *  Performs write operation to Omer analog register specified.
2147  **/
2148 s32 ixgbe_write_analog_reg8_82599(struct ixgbe_hw *hw, u32 reg, u8 val)
2149 {
2150         u32  core_ctl;
2151
2152         DEBUGFUNC("ixgbe_write_analog_reg8_82599");
2153
2154         core_ctl = (reg << 8) | val;
2155         IXGBE_WRITE_REG(hw, IXGBE_CORECTL, core_ctl);
2156         IXGBE_WRITE_FLUSH(hw);
2157         usec_delay(10);
2158
2159         return IXGBE_SUCCESS;
2160 }
2161
2162 /**
2163  *  ixgbe_start_hw_82599 - Prepare hardware for Tx/Rx
2164  *  @hw: pointer to hardware structure
2165  *
2166  *  Starts the hardware using the generic start_hw function
2167  *  and the generation start_hw function.
2168  *  Then performs revision-specific operations, if any.
2169  **/
2170 s32 ixgbe_start_hw_82599(struct ixgbe_hw *hw)
2171 {
2172         s32 ret_val = IXGBE_SUCCESS;
2173
2174         DEBUGFUNC("ixgbe_start_hw_82599");
2175
2176         ret_val = ixgbe_start_hw_generic(hw);
2177         if (ret_val != IXGBE_SUCCESS)
2178                 goto out;
2179
2180         ret_val = ixgbe_start_hw_gen2(hw);
2181         if (ret_val != IXGBE_SUCCESS)
2182                 goto out;
2183
2184         /* We need to run link autotry after the driver loads */
2185         hw->mac.autotry_restart = true;
2186
2187         if (ret_val == IXGBE_SUCCESS)
2188                 ret_val = ixgbe_verify_fw_version_82599(hw);
2189 out:
2190         return ret_val;
2191 }
2192
2193 /**
2194  *  ixgbe_identify_phy_82599 - Get physical layer module
2195  *  @hw: pointer to hardware structure
2196  *
2197  *  Determines the physical layer module found on the current adapter.
2198  *  If PHY already detected, maintains current PHY type in hw struct,
2199  *  otherwise executes the PHY detection routine.
2200  **/
2201 s32 ixgbe_identify_phy_82599(struct ixgbe_hw *hw)
2202 {
2203         s32 status;
2204
2205         DEBUGFUNC("ixgbe_identify_phy_82599");
2206
2207         /* Detect PHY if not unknown - returns success if already detected. */
2208         status = ixgbe_identify_phy_generic(hw);
2209         if (status != IXGBE_SUCCESS) {
2210                 /* 82599 10GBASE-T requires an external PHY */
2211                 if (hw->mac.ops.get_media_type(hw) == ixgbe_media_type_copper)
2212                         return status;
2213                 else
2214                         status = ixgbe_identify_module_generic(hw);
2215         }
2216
2217         /* Set PHY type none if no PHY detected */
2218         if (hw->phy.type == ixgbe_phy_unknown) {
2219                 hw->phy.type = ixgbe_phy_none;
2220                 return IXGBE_SUCCESS;
2221         }
2222
2223         /* Return error if SFP module has been detected but is not supported */
2224         if (hw->phy.type == ixgbe_phy_sfp_unsupported)
2225                 return IXGBE_ERR_SFP_NOT_SUPPORTED;
2226
2227         return status;
2228 }
2229
2230 /**
2231  *  ixgbe_get_supported_physical_layer_82599 - Returns physical layer type
2232  *  @hw: pointer to hardware structure
2233  *
2234  *  Determines physical layer capabilities of the current configuration.
2235  **/
2236 u32 ixgbe_get_supported_physical_layer_82599(struct ixgbe_hw *hw)
2237 {
2238         u32 physical_layer = IXGBE_PHYSICAL_LAYER_UNKNOWN;
2239         u32 autoc = IXGBE_READ_REG(hw, IXGBE_AUTOC);
2240         u32 autoc2 = IXGBE_READ_REG(hw, IXGBE_AUTOC2);
2241         u32 pma_pmd_10g_serial = autoc2 & IXGBE_AUTOC2_10G_SERIAL_PMA_PMD_MASK;
2242         u32 pma_pmd_10g_parallel = autoc & IXGBE_AUTOC_10G_PMA_PMD_MASK;
2243         u32 pma_pmd_1g = autoc & IXGBE_AUTOC_1G_PMA_PMD_MASK;
2244         u16 ext_ability = 0;
2245
2246         DEBUGFUNC("ixgbe_get_support_physical_layer_82599");
2247
2248         hw->phy.ops.identify(hw);
2249
2250         switch (hw->phy.type) {
2251         case ixgbe_phy_tn:
2252         case ixgbe_phy_cu_unknown:
2253                 hw->phy.ops.read_reg(hw, IXGBE_MDIO_PHY_EXT_ABILITY,
2254                 IXGBE_MDIO_PMA_PMD_DEV_TYPE, &ext_ability);
2255                 if (ext_ability & IXGBE_MDIO_PHY_10GBASET_ABILITY)
2256                         physical_layer |= IXGBE_PHYSICAL_LAYER_10GBASE_T;
2257                 if (ext_ability & IXGBE_MDIO_PHY_1000BASET_ABILITY)
2258                         physical_layer |= IXGBE_PHYSICAL_LAYER_1000BASE_T;
2259                 if (ext_ability & IXGBE_MDIO_PHY_100BASETX_ABILITY)
2260                         physical_layer |= IXGBE_PHYSICAL_LAYER_100BASE_TX;
2261                 goto out;
2262         default:
2263                 break;
2264         }
2265
2266         switch (autoc & IXGBE_AUTOC_LMS_MASK) {
2267         case IXGBE_AUTOC_LMS_1G_AN:
2268         case IXGBE_AUTOC_LMS_1G_LINK_NO_AN:
2269                 if (pma_pmd_1g == IXGBE_AUTOC_1G_KX_BX) {
2270                         physical_layer = IXGBE_PHYSICAL_LAYER_1000BASE_KX |
2271                             IXGBE_PHYSICAL_LAYER_1000BASE_BX;
2272                         goto out;
2273                 } else
2274                         /* SFI mode so read SFP module */
2275                         goto sfp_check;
2276                 break;
2277         case IXGBE_AUTOC_LMS_10G_LINK_NO_AN:
2278                 if (pma_pmd_10g_parallel == IXGBE_AUTOC_10G_CX4)
2279                         physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_CX4;
2280                 else if (pma_pmd_10g_parallel == IXGBE_AUTOC_10G_KX4)
2281                         physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_KX4;
2282                 else if (pma_pmd_10g_parallel == IXGBE_AUTOC_10G_XAUI)
2283                         physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_XAUI;
2284                 goto out;
2285                 break;
2286         case IXGBE_AUTOC_LMS_10G_SERIAL:
2287                 if (pma_pmd_10g_serial == IXGBE_AUTOC2_10G_KR) {
2288                         physical_layer = IXGBE_PHYSICAL_LAYER_10GBASE_KR;
2289                         goto out;
2290                 } else if (pma_pmd_10g_serial == IXGBE_AUTOC2_10G_SFI)
2291                         goto sfp_check;
2292                 break;
2293         case IXGBE_AUTOC_LMS_KX4_KX_KR:
2294         case IXGBE_AUTOC_LMS_KX4_KX_KR_1G_AN:
2295                 if (autoc & IXGBE_AUTOC_KX_SUPP)
2296                         physical_layer |= IXGBE_PHYSICAL_LAYER_1000BASE_KX;
2297                 if (autoc & IXGBE_AUTOC_KX4_SUPP)
2298                         physical_layer |= IXGBE_PHYSICAL_LAYER_10GBASE_KX4;
2299                 if (autoc & IXGBE_AUTOC_KR_SUPP)
2300                         physical_layer |= IXGBE_PHYSICAL_LAYER_10GBASE_KR;
2301                 goto out;
2302                 break;
2303         default:
2304                 goto out;
2305                 break;
2306         }
2307
2308 sfp_check:
2309         /* SFP check must be done last since DA modules are sometimes used to
2310          * test KR mode -  we need to id KR mode correctly before SFP module.
2311          * Call identify_sfp because the pluggable module may have changed */
2312         physical_layer = ixgbe_get_supported_phy_sfp_layer_generic(hw);
2313 out:
2314         return physical_layer;
2315 }
2316
2317 /**
2318  *  ixgbe_enable_rx_dma_82599 - Enable the Rx DMA unit on 82599
2319  *  @hw: pointer to hardware structure
2320  *  @regval: register value to write to RXCTRL
2321  *
2322  *  Enables the Rx DMA unit for 82599
2323  **/
2324 s32 ixgbe_enable_rx_dma_82599(struct ixgbe_hw *hw, u32 regval)
2325 {
2326
2327         DEBUGFUNC("ixgbe_enable_rx_dma_82599");
2328
2329         /*
2330          * Workaround for 82599 silicon errata when enabling the Rx datapath.
2331          * If traffic is incoming before we enable the Rx unit, it could hang
2332          * the Rx DMA unit.  Therefore, make sure the security engine is
2333          * completely disabled prior to enabling the Rx unit.
2334          */
2335
2336         hw->mac.ops.disable_sec_rx_path(hw);
2337
2338         if (regval & IXGBE_RXCTRL_RXEN)
2339                 ixgbe_enable_rx(hw);
2340         else
2341                 ixgbe_disable_rx(hw);
2342
2343         hw->mac.ops.enable_sec_rx_path(hw);
2344
2345         return IXGBE_SUCCESS;
2346 }
2347
2348 /**
2349  *  ixgbe_verify_fw_version_82599 - verify FW version for 82599
2350  *  @hw: pointer to hardware structure
2351  *
2352  *  Verifies that installed the firmware version is 0.6 or higher
2353  *  for SFI devices. All 82599 SFI devices should have version 0.6 or higher.
2354  *
2355  *  Returns IXGBE_ERR_EEPROM_VERSION if the FW is not present or
2356  *  if the FW version is not supported.
2357  **/
2358 STATIC s32 ixgbe_verify_fw_version_82599(struct ixgbe_hw *hw)
2359 {
2360         s32 status = IXGBE_ERR_EEPROM_VERSION;
2361         u16 fw_offset, fw_ptp_cfg_offset;
2362         u16 fw_version;
2363
2364         DEBUGFUNC("ixgbe_verify_fw_version_82599");
2365
2366         /* firmware check is only necessary for SFI devices */
2367         if (hw->phy.media_type != ixgbe_media_type_fiber) {
2368                 status = IXGBE_SUCCESS;
2369                 goto fw_version_out;
2370         }
2371
2372         /* get the offset to the Firmware Module block */
2373         if (hw->eeprom.ops.read(hw, IXGBE_FW_PTR, &fw_offset)) {
2374                 ERROR_REPORT2(IXGBE_ERROR_INVALID_STATE,
2375                               "eeprom read at offset %d failed", IXGBE_FW_PTR);
2376                 return IXGBE_ERR_EEPROM_VERSION;
2377         }
2378
2379         if ((fw_offset == 0) || (fw_offset == 0xFFFF))
2380                 goto fw_version_out;
2381
2382         /* get the offset to the Pass Through Patch Configuration block */
2383         if (hw->eeprom.ops.read(hw, (fw_offset +
2384                                  IXGBE_FW_PASSTHROUGH_PATCH_CONFIG_PTR),
2385                                  &fw_ptp_cfg_offset)) {
2386                 ERROR_REPORT2(IXGBE_ERROR_INVALID_STATE,
2387                               "eeprom read at offset %d failed",
2388                               fw_offset +
2389                               IXGBE_FW_PASSTHROUGH_PATCH_CONFIG_PTR);
2390                 return IXGBE_ERR_EEPROM_VERSION;
2391         }
2392
2393         if ((fw_ptp_cfg_offset == 0) || (fw_ptp_cfg_offset == 0xFFFF))
2394                 goto fw_version_out;
2395
2396         /* get the firmware version */
2397         if (hw->eeprom.ops.read(hw, (fw_ptp_cfg_offset +
2398                             IXGBE_FW_PATCH_VERSION_4), &fw_version)) {
2399                 ERROR_REPORT2(IXGBE_ERROR_INVALID_STATE,
2400                               "eeprom read at offset %d failed",
2401                               fw_ptp_cfg_offset + IXGBE_FW_PATCH_VERSION_4);
2402                 return IXGBE_ERR_EEPROM_VERSION;
2403         }
2404
2405         if (fw_version > 0x5)
2406                 status = IXGBE_SUCCESS;
2407
2408 fw_version_out:
2409         return status;
2410 }
2411
2412 /**
2413  *  ixgbe_verify_lesm_fw_enabled_82599 - Checks LESM FW module state.
2414  *  @hw: pointer to hardware structure
2415  *
2416  *  Returns true if the LESM FW module is present and enabled. Otherwise
2417  *  returns false. Smart Speed must be disabled if LESM FW module is enabled.
2418  **/
2419 bool ixgbe_verify_lesm_fw_enabled_82599(struct ixgbe_hw *hw)
2420 {
2421         bool lesm_enabled = false;
2422         u16 fw_offset, fw_lesm_param_offset, fw_lesm_state;
2423         s32 status;
2424
2425         DEBUGFUNC("ixgbe_verify_lesm_fw_enabled_82599");
2426
2427         /* get the offset to the Firmware Module block */
2428         status = hw->eeprom.ops.read(hw, IXGBE_FW_PTR, &fw_offset);
2429
2430         if ((status != IXGBE_SUCCESS) ||
2431             (fw_offset == 0) || (fw_offset == 0xFFFF))
2432                 goto out;
2433
2434         /* get the offset to the LESM Parameters block */
2435         status = hw->eeprom.ops.read(hw, (fw_offset +
2436                                      IXGBE_FW_LESM_PARAMETERS_PTR),
2437                                      &fw_lesm_param_offset);
2438
2439         if ((status != IXGBE_SUCCESS) ||
2440             (fw_lesm_param_offset == 0) || (fw_lesm_param_offset == 0xFFFF))
2441                 goto out;
2442
2443         /* get the LESM state word */
2444         status = hw->eeprom.ops.read(hw, (fw_lesm_param_offset +
2445                                      IXGBE_FW_LESM_STATE_1),
2446                                      &fw_lesm_state);
2447
2448         if ((status == IXGBE_SUCCESS) &&
2449             (fw_lesm_state & IXGBE_FW_LESM_STATE_ENABLED))
2450                 lesm_enabled = true;
2451
2452 out:
2453         return lesm_enabled;
2454 }
2455
2456 /**
2457  *  ixgbe_read_eeprom_buffer_82599 - Read EEPROM word(s) using
2458  *  fastest available method
2459  *
2460  *  @hw: pointer to hardware structure
2461  *  @offset: offset of  word in EEPROM to read
2462  *  @words: number of words
2463  *  @data: word(s) read from the EEPROM
2464  *
2465  *  Retrieves 16 bit word(s) read from EEPROM
2466  **/
2467 STATIC s32 ixgbe_read_eeprom_buffer_82599(struct ixgbe_hw *hw, u16 offset,
2468                                           u16 words, u16 *data)
2469 {
2470         struct ixgbe_eeprom_info *eeprom = &hw->eeprom;
2471         s32 ret_val = IXGBE_ERR_CONFIG;
2472
2473         DEBUGFUNC("ixgbe_read_eeprom_buffer_82599");
2474
2475         /*
2476          * If EEPROM is detected and can be addressed using 14 bits,
2477          * use EERD otherwise use bit bang
2478          */
2479         if ((eeprom->type == ixgbe_eeprom_spi) &&
2480             (offset + (words - 1) <= IXGBE_EERD_MAX_ADDR))
2481                 ret_val = ixgbe_read_eerd_buffer_generic(hw, offset, words,
2482                                                          data);
2483         else
2484                 ret_val = ixgbe_read_eeprom_buffer_bit_bang_generic(hw, offset,
2485                                                                     words,
2486                                                                     data);
2487
2488         return ret_val;
2489 }
2490
2491 /**
2492  *  ixgbe_read_eeprom_82599 - Read EEPROM word using
2493  *  fastest available method
2494  *
2495  *  @hw: pointer to hardware structure
2496  *  @offset: offset of  word in the EEPROM to read
2497  *  @data: word read from the EEPROM
2498  *
2499  *  Reads a 16 bit word from the EEPROM
2500  **/
2501 STATIC s32 ixgbe_read_eeprom_82599(struct ixgbe_hw *hw,
2502                                    u16 offset, u16 *data)
2503 {
2504         struct ixgbe_eeprom_info *eeprom = &hw->eeprom;
2505         s32 ret_val = IXGBE_ERR_CONFIG;
2506
2507         DEBUGFUNC("ixgbe_read_eeprom_82599");
2508
2509         /*
2510          * If EEPROM is detected and can be addressed using 14 bits,
2511          * use EERD otherwise use bit bang
2512          */
2513         if ((eeprom->type == ixgbe_eeprom_spi) &&
2514             (offset <= IXGBE_EERD_MAX_ADDR))
2515                 ret_val = ixgbe_read_eerd_generic(hw, offset, data);
2516         else
2517                 ret_val = ixgbe_read_eeprom_bit_bang_generic(hw, offset, data);
2518
2519         return ret_val;
2520 }
2521
2522 /**
2523  * ixgbe_reset_pipeline_82599 - perform pipeline reset
2524  *
2525  *  @hw: pointer to hardware structure
2526  *
2527  * Reset pipeline by asserting Restart_AN together with LMS change to ensure
2528  * full pipeline reset.  This function assumes the SW/FW lock is held.
2529  **/
2530 s32 ixgbe_reset_pipeline_82599(struct ixgbe_hw *hw)
2531 {
2532         s32 ret_val;
2533         u32 anlp1_reg = 0;
2534         u32 i, autoc_reg, autoc2_reg;
2535
2536         /* Enable link if disabled in NVM */
2537         autoc2_reg = IXGBE_READ_REG(hw, IXGBE_AUTOC2);
2538         if (autoc2_reg & IXGBE_AUTOC2_LINK_DISABLE_MASK) {
2539                 autoc2_reg &= ~IXGBE_AUTOC2_LINK_DISABLE_MASK;
2540                 IXGBE_WRITE_REG(hw, IXGBE_AUTOC2, autoc2_reg);
2541                 IXGBE_WRITE_FLUSH(hw);
2542         }
2543
2544         autoc_reg = IXGBE_READ_REG(hw, IXGBE_AUTOC);
2545         autoc_reg |= IXGBE_AUTOC_AN_RESTART;
2546         /* Write AUTOC register with toggled LMS[2] bit and Restart_AN */
2547         IXGBE_WRITE_REG(hw, IXGBE_AUTOC,
2548                         autoc_reg ^ (0x4 << IXGBE_AUTOC_LMS_SHIFT));
2549         /* Wait for AN to leave state 0 */
2550         for (i = 0; i < 10; i++) {
2551                 msec_delay(4);
2552                 anlp1_reg = IXGBE_READ_REG(hw, IXGBE_ANLP1);
2553                 if (anlp1_reg & IXGBE_ANLP1_AN_STATE_MASK)
2554                         break;
2555         }
2556
2557         if (!(anlp1_reg & IXGBE_ANLP1_AN_STATE_MASK)) {
2558                 DEBUGOUT("auto negotiation not completed\n");
2559                 ret_val = IXGBE_ERR_RESET_FAILED;
2560                 goto reset_pipeline_out;
2561         }
2562
2563         ret_val = IXGBE_SUCCESS;
2564
2565 reset_pipeline_out:
2566         /* Write AUTOC register with original LMS field and Restart_AN */
2567         IXGBE_WRITE_REG(hw, IXGBE_AUTOC, autoc_reg);
2568         IXGBE_WRITE_FLUSH(hw);
2569
2570         return ret_val;
2571 }
2572
2573
2574 /**
2575  *  ixgbe_read_i2c_byte_82599 - Reads 8 bit word over I2C
2576  *  @hw: pointer to hardware structure
2577  *  @byte_offset: byte offset to read
2578  *  @data: value read
2579  *
2580  *  Performs byte read operation to SFP module's EEPROM over I2C interface at
2581  *  a specified device address.
2582  **/
2583 STATIC s32 ixgbe_read_i2c_byte_82599(struct ixgbe_hw *hw, u8 byte_offset,
2584                                 u8 dev_addr, u8 *data)
2585 {
2586         u32 esdp;
2587         s32 status;
2588         s32 timeout = 200;
2589
2590         DEBUGFUNC("ixgbe_read_i2c_byte_82599");
2591
2592         if (hw->phy.qsfp_shared_i2c_bus == TRUE) {
2593                 /* Acquire I2C bus ownership. */
2594                 esdp = IXGBE_READ_REG(hw, IXGBE_ESDP);
2595                 esdp |= IXGBE_ESDP_SDP0;
2596                 IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp);
2597                 IXGBE_WRITE_FLUSH(hw);
2598
2599                 while (timeout) {
2600                         esdp = IXGBE_READ_REG(hw, IXGBE_ESDP);
2601                         if (esdp & IXGBE_ESDP_SDP1)
2602                                 break;
2603
2604                         msec_delay(5);
2605                         timeout--;
2606                 }
2607
2608                 if (!timeout) {
2609                         DEBUGOUT("Driver can't access resource,"
2610                                  " acquiring I2C bus timeout.\n");
2611                         status = IXGBE_ERR_I2C;
2612                         goto release_i2c_access;
2613                 }
2614         }
2615
2616         status = ixgbe_read_i2c_byte_generic(hw, byte_offset, dev_addr, data);
2617
2618 release_i2c_access:
2619
2620         if (hw->phy.qsfp_shared_i2c_bus == TRUE) {
2621                 /* Release I2C bus ownership. */
2622                 esdp = IXGBE_READ_REG(hw, IXGBE_ESDP);
2623                 esdp &= ~IXGBE_ESDP_SDP0;
2624                 IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp);
2625                 IXGBE_WRITE_FLUSH(hw);
2626         }
2627
2628         return status;
2629 }
2630
2631 /**
2632  *  ixgbe_write_i2c_byte_82599 - Writes 8 bit word over I2C
2633  *  @hw: pointer to hardware structure
2634  *  @byte_offset: byte offset to write
2635  *  @data: value to write
2636  *
2637  *  Performs byte write operation to SFP module's EEPROM over I2C interface at
2638  *  a specified device address.
2639  **/
2640 STATIC s32 ixgbe_write_i2c_byte_82599(struct ixgbe_hw *hw, u8 byte_offset,
2641                                  u8 dev_addr, u8 data)
2642 {
2643         u32 esdp;
2644         s32 status;
2645         s32 timeout = 200;
2646
2647         DEBUGFUNC("ixgbe_write_i2c_byte_82599");
2648
2649         if (hw->phy.qsfp_shared_i2c_bus == TRUE) {
2650                 /* Acquire I2C bus ownership. */
2651                 esdp = IXGBE_READ_REG(hw, IXGBE_ESDP);
2652                 esdp |= IXGBE_ESDP_SDP0;
2653                 IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp);
2654                 IXGBE_WRITE_FLUSH(hw);
2655
2656                 while (timeout) {
2657                         esdp = IXGBE_READ_REG(hw, IXGBE_ESDP);
2658                         if (esdp & IXGBE_ESDP_SDP1)
2659                                 break;
2660
2661                         msec_delay(5);
2662                         timeout--;
2663                 }
2664
2665                 if (!timeout) {
2666                         DEBUGOUT("Driver can't access resource,"
2667                                  " acquiring I2C bus timeout.\n");
2668                         status = IXGBE_ERR_I2C;
2669                         goto release_i2c_access;
2670                 }
2671         }
2672
2673         status = ixgbe_write_i2c_byte_generic(hw, byte_offset, dev_addr, data);
2674
2675 release_i2c_access:
2676
2677         if (hw->phy.qsfp_shared_i2c_bus == TRUE) {
2678                 /* Release I2C bus ownership. */
2679                 esdp = IXGBE_READ_REG(hw, IXGBE_ESDP);
2680                 esdp &= ~IXGBE_ESDP_SDP0;
2681                 IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp);
2682                 IXGBE_WRITE_FLUSH(hw);
2683         }
2684
2685         return status;
2686 }
2687