lib/librte_pmd_ixgbe/ixgbe/ixgbe_82599.c

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