lib/librte_pmd_ixgbe/ixgbe/ixgbe_82599.c

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