lib/librte_pmd_ixgbe/ixgbe/ixgbe_82599.c

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