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