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