lib/librte_pmd_ixgbe/ixgbe/ixgbe_82599.c

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