sys/dev/ixgbe/ixgbe_common.c

   1 /******************************************************************************
   2
   3   Copyright (c) 2001-2015, 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 /*$FreeBSD$*/
  34
  35 #include "ixgbe_common.h"
  36 #include "ixgbe_phy.h"
  37 #include "ixgbe_dcb.h"
  38 #include "ixgbe_dcb_82599.h"
  39 #include "ixgbe_api.h"
  40
  41 static s32 ixgbe_acquire_eeprom(struct ixgbe_hw *hw);
  42 static s32 ixgbe_get_eeprom_semaphore(struct ixgbe_hw *hw);
  43 static void ixgbe_release_eeprom_semaphore(struct ixgbe_hw *hw);
  44 static s32 ixgbe_ready_eeprom(struct ixgbe_hw *hw);
  45 static void ixgbe_standby_eeprom(struct ixgbe_hw *hw);
  46 static void ixgbe_shift_out_eeprom_bits(struct ixgbe_hw *hw, u16 data,
  47                                         u16 count);
  48 static u16 ixgbe_shift_in_eeprom_bits(struct ixgbe_hw *hw, u16 count);
  49 static void ixgbe_raise_eeprom_clk(struct ixgbe_hw *hw, u32 *eec);
  50 static void ixgbe_lower_eeprom_clk(struct ixgbe_hw *hw, u32 *eec);
  51 static void ixgbe_release_eeprom(struct ixgbe_hw *hw);
  52
  53 static s32 ixgbe_mta_vector(struct ixgbe_hw *hw, u8 *mc_addr);
  54 static s32 ixgbe_get_san_mac_addr_offset(struct ixgbe_hw *hw,
  55                                          u16 *san_mac_offset);
  56 static s32 ixgbe_read_eeprom_buffer_bit_bang(struct ixgbe_hw *hw, u16 offset,
  57                                              u16 words, u16 *data);
  58 static s32 ixgbe_write_eeprom_buffer_bit_bang(struct ixgbe_hw *hw, u16 offset,
  59                                               u16 words, u16 *data);
  60 static s32 ixgbe_detect_eeprom_page_size_generic(struct ixgbe_hw *hw,
  61                                                  u16 offset);
  62
  63 /**
  64  *  ixgbe_init_ops_generic - Inits function ptrs
  65  *  @hw: pointer to the hardware structure
  66  *
  67  *  Initialize the function pointers.
  68  **/
  69 s32 ixgbe_init_ops_generic(struct ixgbe_hw *hw)
  70 {
  71         struct ixgbe_eeprom_info *eeprom = &hw->eeprom;
  72         struct ixgbe_mac_info *mac = &hw->mac;
  73         u32 eec = IXGBE_READ_REG(hw, IXGBE_EEC_BY_MAC(hw));
  74
  75         DEBUGFUNC("ixgbe_init_ops_generic");
  76
  77         /* EEPROM */
  78         eeprom->ops.init_params = ixgbe_init_eeprom_params_generic;
  79         /* If EEPROM is valid (bit 8 = 1), use EERD otherwise use bit bang */
  80         if (eec & IXGBE_EEC_PRES) {
  81                 eeprom->ops.read = ixgbe_read_eerd_generic;
  82                 eeprom->ops.read_buffer = ixgbe_read_eerd_buffer_generic;
  83         } else {
  84                 eeprom->ops.read = ixgbe_read_eeprom_bit_bang_generic;
  85                 eeprom->ops.read_buffer =
  86                                  ixgbe_read_eeprom_buffer_bit_bang_generic;
  87         }
  88         eeprom->ops.write = ixgbe_write_eeprom_generic;
  89         eeprom->ops.write_buffer = ixgbe_write_eeprom_buffer_bit_bang_generic;
  90         eeprom->ops.validate_checksum =
  91                                       ixgbe_validate_eeprom_checksum_generic;
  92         eeprom->ops.update_checksum = ixgbe_update_eeprom_checksum_generic;
  93         eeprom->ops.calc_checksum = ixgbe_calc_eeprom_checksum_generic;
  94
  95         /* MAC */
  96         mac->ops.init_hw = ixgbe_init_hw_generic;
  97         mac->ops.reset_hw = NULL;
  98         mac->ops.start_hw = ixgbe_start_hw_generic;
  99         mac->ops.clear_hw_cntrs = ixgbe_clear_hw_cntrs_generic;
 100         mac->ops.get_media_type = NULL;
 101         mac->ops.get_supported_physical_layer = NULL;
 102         mac->ops.enable_rx_dma = ixgbe_enable_rx_dma_generic;
 103         mac->ops.get_mac_addr = ixgbe_get_mac_addr_generic;
 104         mac->ops.stop_adapter = ixgbe_stop_adapter_generic;
 105         mac->ops.get_bus_info = ixgbe_get_bus_info_generic;
 106         mac->ops.set_lan_id = ixgbe_set_lan_id_multi_port_pcie;
 107         mac->ops.acquire_swfw_sync = ixgbe_acquire_swfw_sync;
 108         mac->ops.release_swfw_sync = ixgbe_release_swfw_sync;
 109         mac->ops.prot_autoc_read = prot_autoc_read_generic;
 110         mac->ops.prot_autoc_write = prot_autoc_write_generic;
 111
 112         /* LEDs */
 113         mac->ops.led_on = ixgbe_led_on_generic;
 114         mac->ops.led_off = ixgbe_led_off_generic;
 115         mac->ops.blink_led_start = ixgbe_blink_led_start_generic;
 116         mac->ops.blink_led_stop = ixgbe_blink_led_stop_generic;
 117
 118         /* RAR, Multicast, VLAN */
 119         mac->ops.set_rar = ixgbe_set_rar_generic;
 120         mac->ops.clear_rar = ixgbe_clear_rar_generic;
 121         mac->ops.insert_mac_addr = NULL;
 122         mac->ops.set_vmdq = NULL;
 123         mac->ops.clear_vmdq = NULL;
 124         mac->ops.init_rx_addrs = ixgbe_init_rx_addrs_generic;
 125         mac->ops.update_uc_addr_list = ixgbe_update_uc_addr_list_generic;
 126         mac->ops.update_mc_addr_list = ixgbe_update_mc_addr_list_generic;
 127         mac->ops.enable_mc = ixgbe_enable_mc_generic;
 128         mac->ops.disable_mc = ixgbe_disable_mc_generic;
 129         mac->ops.clear_vfta = NULL;
 130         mac->ops.set_vfta = NULL;
 131         mac->ops.set_vlvf = NULL;
 132         mac->ops.init_uta_tables = NULL;
 133         mac->ops.enable_rx = ixgbe_enable_rx_generic;
 134         mac->ops.disable_rx = ixgbe_disable_rx_generic;
 135
 136         /* Flow Control */
 137         mac->ops.fc_enable = ixgbe_fc_enable_generic;
 138         mac->ops.setup_fc = ixgbe_setup_fc_generic;
 139
 140         /* Link */
 141         mac->ops.get_link_capabilities = NULL;
 142         mac->ops.setup_link = NULL;
 143         mac->ops.check_link = NULL;
 144         mac->ops.dmac_config = NULL;
 145         mac->ops.dmac_update_tcs = NULL;
 146         mac->ops.dmac_config_tcs = NULL;
 147
 148         return IXGBE_SUCCESS;
 149 }
 150
 151 /**
 152  * ixgbe_device_supports_autoneg_fc - Check if device supports autonegotiation
 153  * of flow control
 154  * @hw: pointer to hardware structure
 155  *
 156  * This function returns TRUE if the device supports flow control
 157  * autonegotiation, and FALSE if it does not.
 158  *
 159  **/
 160 bool ixgbe_device_supports_autoneg_fc(struct ixgbe_hw *hw)
 161 {
 162         bool supported = FALSE;
 163         ixgbe_link_speed speed;
 164         bool link_up;
 165
 166         DEBUGFUNC("ixgbe_device_supports_autoneg_fc");
 167
 168         switch (hw->phy.media_type) {
 169         case ixgbe_media_type_fiber_fixed:
 170         case ixgbe_media_type_fiber_qsfp:
 171         case ixgbe_media_type_fiber:
 172                 hw->mac.ops.check_link(hw, &speed, &link_up, FALSE);
 173                 /* if link is down, assume supported */
 174                 if (link_up)
 175                         supported = speed == IXGBE_LINK_SPEED_1GB_FULL ?
 176                                 TRUE : FALSE;
 177                 else
 178                         supported = TRUE;
 179                 break;
 180         case ixgbe_media_type_backplane:
 181                 supported = TRUE;
 182                 break;
 183         case ixgbe_media_type_copper:
 184                 /* only some copper devices support flow control autoneg */
 185                 switch (hw->device_id) {
 186                 case IXGBE_DEV_ID_82599_T3_LOM:
 187                 case IXGBE_DEV_ID_X540T:
 188                 case IXGBE_DEV_ID_X540T1:
 189                 case IXGBE_DEV_ID_X540_BYPASS:
 190                 case IXGBE_DEV_ID_X550T:
 191                 case IXGBE_DEV_ID_X550T1:
 192                 case IXGBE_DEV_ID_X550EM_X_10G_T:
 193                         supported = TRUE;
 194                         break;
 195                 default:
 196                         supported = FALSE;
 197                 }
 198         default:
 199                 break;
 200         }
 201
 202         if (!supported) {
 203                 ERROR_REPORT2(IXGBE_ERROR_UNSUPPORTED,
 204                       "Device %x does not support flow control autoneg",
 205                       hw->device_id);
 206         }
 207
 208         return supported;
 209 }
 210
 211 /**
 212  *  ixgbe_setup_fc_generic - Set up flow control
 213  *  @hw: pointer to hardware structure
 214  *
 215  *  Called at init time to set up flow control.
 216  **/
 217 s32 ixgbe_setup_fc_generic(struct ixgbe_hw *hw)
 218 {
 219         s32 ret_val = IXGBE_SUCCESS;
 220         u32 reg = 0, reg_bp = 0;
 221         u16 reg_cu = 0;
 222         bool locked = FALSE;
 223
 224         DEBUGFUNC("ixgbe_setup_fc_generic");
 225
 226         /* Validate the requested mode */
 227         if (hw->fc.strict_ieee && hw->fc.requested_mode == ixgbe_fc_rx_pause) {
 228                 ERROR_REPORT1(IXGBE_ERROR_UNSUPPORTED,
 229                            "ixgbe_fc_rx_pause not valid in strict IEEE mode\n");
 230                 ret_val = IXGBE_ERR_INVALID_LINK_SETTINGS;
 231                 goto out;
 232         }
 233
 234         /*
 235          * 10gig parts do not have a word in the EEPROM to determine the
 236          * default flow control setting, so we explicitly set it to full.
 237          */
 238         if (hw->fc.requested_mode == ixgbe_fc_default)
 239                 hw->fc.requested_mode = ixgbe_fc_full;
 240
 241         /*
 242          * Set up the 1G and 10G flow control advertisement registers so the
 243          * HW will be able to do fc autoneg once the cable is plugged in.  If
 244          * we link at 10G, the 1G advertisement is harmless and vice versa.
 245          */
 246         switch (hw->phy.media_type) {
 247         case ixgbe_media_type_backplane:
 248                 /* some MAC's need RMW protection on AUTOC */
 249                 ret_val = hw->mac.ops.prot_autoc_read(hw, &locked, &reg_bp);
 250                 if (ret_val != IXGBE_SUCCESS)
 251                         goto out;
 252
 253                 /* only backplane uses autoc so fall though */
 254         case ixgbe_media_type_fiber_fixed:
 255         case ixgbe_media_type_fiber_qsfp:
 256         case ixgbe_media_type_fiber:
 257                 reg = IXGBE_READ_REG(hw, IXGBE_PCS1GANA);
 258
 259                 break;
 260         case ixgbe_media_type_copper:
 261                 hw->phy.ops.read_reg(hw, IXGBE_MDIO_AUTO_NEG_ADVT,
 262                                      IXGBE_MDIO_AUTO_NEG_DEV_TYPE, &reg_cu);
 263                 break;
 264         default:
 265                 break;
 266         }
 267
 268         /*
 269          * The possible values of fc.requested_mode are:
 270          * 0: Flow control is completely disabled
 271          * 1: Rx flow control is enabled (we can receive pause frames,
 272          *    but not send pause frames).
 273          * 2: Tx flow control is enabled (we can send pause frames but
 274          *    we do not support receiving pause frames).
 275          * 3: Both Rx and Tx flow control (symmetric) are enabled.
 276          * other: Invalid.
 277          */
 278         switch (hw->fc.requested_mode) {
 279         case ixgbe_fc_none:
 280                 /* Flow control completely disabled by software override. */
 281                 reg &= ~(IXGBE_PCS1GANA_SYM_PAUSE | IXGBE_PCS1GANA_ASM_PAUSE);
 282                 if (hw->phy.media_type == ixgbe_media_type_backplane)
 283                         reg_bp &= ~(IXGBE_AUTOC_SYM_PAUSE |
 284                                     IXGBE_AUTOC_ASM_PAUSE);
 285                 else if (hw->phy.media_type == ixgbe_media_type_copper)
 286                         reg_cu &= ~(IXGBE_TAF_SYM_PAUSE | IXGBE_TAF_ASM_PAUSE);
 287                 break;
 288         case ixgbe_fc_tx_pause:
 289                 /*
 290                  * Tx Flow control is enabled, and Rx Flow control is
 291                  * disabled by software override.
 292                  */
 293                 reg |= IXGBE_PCS1GANA_ASM_PAUSE;
 294                 reg &= ~IXGBE_PCS1GANA_SYM_PAUSE;
 295                 if (hw->phy.media_type == ixgbe_media_type_backplane) {
 296                         reg_bp |= IXGBE_AUTOC_ASM_PAUSE;
 297                         reg_bp &= ~IXGBE_AUTOC_SYM_PAUSE;
 298                 } else if (hw->phy.media_type == ixgbe_media_type_copper) {
 299                         reg_cu |= IXGBE_TAF_ASM_PAUSE;
 300                         reg_cu &= ~IXGBE_TAF_SYM_PAUSE;
 301                 }
 302                 break;
 303         case ixgbe_fc_rx_pause:
 304                 /*
 305                  * Rx Flow control is enabled and Tx Flow control is
 306                  * disabled by software override. Since there really
 307                  * isn't a way to advertise that we are capable of RX
 308                  * Pause ONLY, we will advertise that we support both
 309                  * symmetric and asymmetric Rx PAUSE, as such we fall
 310                  * through to the fc_full statement.  Later, we will
 311                  * disable the adapter's ability to send PAUSE frames.
 312                  */
 313         case ixgbe_fc_full:
 314                 /* Flow control (both Rx and Tx) is enabled by SW override. */
 315                 reg |= IXGBE_PCS1GANA_SYM_PAUSE | IXGBE_PCS1GANA_ASM_PAUSE;
 316                 if (hw->phy.media_type == ixgbe_media_type_backplane)
 317                         reg_bp |= IXGBE_AUTOC_SYM_PAUSE |
 318                                   IXGBE_AUTOC_ASM_PAUSE;
 319                 else if (hw->phy.media_type == ixgbe_media_type_copper)
 320                         reg_cu |= IXGBE_TAF_SYM_PAUSE | IXGBE_TAF_ASM_PAUSE;
 321                 break;
 322         default:
 323                 ERROR_REPORT1(IXGBE_ERROR_ARGUMENT,
 324                              "Flow control param set incorrectly\n");
 325                 ret_val = IXGBE_ERR_CONFIG;
 326                 goto out;
 327                 break;
 328         }
 329
 330         if (hw->mac.type < ixgbe_mac_X540) {
 331                 /*
 332                  * Enable auto-negotiation between the MAC & PHY;
 333                  * the MAC will advertise clause 37 flow control.
 334                  */
 335                 IXGBE_WRITE_REG(hw, IXGBE_PCS1GANA, reg);
 336                 reg = IXGBE_READ_REG(hw, IXGBE_PCS1GLCTL);
 337
 338                 /* Disable AN timeout */
 339                 if (hw->fc.strict_ieee)
 340                         reg &= ~IXGBE_PCS1GLCTL_AN_1G_TIMEOUT_EN;
 341
 342                 IXGBE_WRITE_REG(hw, IXGBE_PCS1GLCTL, reg);
 343                 DEBUGOUT1("Set up FC; PCS1GLCTL = 0x%08X\n", reg);
 344         }
 345
 346         /*
 347          * AUTOC restart handles negotiation of 1G and 10G on backplane
 348          * and copper. There is no need to set the PCS1GCTL register.
 349          *
 350          */
 351         if (hw->phy.media_type == ixgbe_media_type_backplane) {
 352                 reg_bp |= IXGBE_AUTOC_AN_RESTART;
 353                 ret_val = hw->mac.ops.prot_autoc_write(hw, reg_bp, locked);
 354                 if (ret_val)
 355                         goto out;
 356         } else if ((hw->phy.media_type == ixgbe_media_type_copper) &&
 357                     (ixgbe_device_supports_autoneg_fc(hw))) {
 358                 hw->phy.ops.write_reg(hw, IXGBE_MDIO_AUTO_NEG_ADVT,
 359                                       IXGBE_MDIO_AUTO_NEG_DEV_TYPE, reg_cu);
 360         }
 361
 362         DEBUGOUT1("Set up FC; PCS1GLCTL = 0x%08X\n", reg);
 363 out:
 364         return ret_val;
 365 }
 366
 367 /**
 368  *  ixgbe_start_hw_generic - Prepare hardware for Tx/Rx
 369  *  @hw: pointer to hardware structure
 370  *
 371  *  Starts the hardware by filling the bus info structure and media type, clears
 372  *  all on chip counters, initializes receive address registers, multicast
 373  *  table, VLAN filter table, calls routine to set up link and flow control
 374  *  settings, and leaves transmit and receive units disabled and uninitialized
 375  **/
 376 s32 ixgbe_start_hw_generic(struct ixgbe_hw *hw)
 377 {
 378         s32 ret_val;
 379         u32 ctrl_ext;
 380
 381         DEBUGFUNC("ixgbe_start_hw_generic");
 382
 383         /* Set the media type */
 384         hw->phy.media_type = hw->mac.ops.get_media_type(hw);
 385
 386         /* PHY ops initialization must be done in reset_hw() */
 387
 388         /* Clear the VLAN filter table */
 389         hw->mac.ops.clear_vfta(hw);
 390
 391         /* Clear statistics registers */
 392         hw->mac.ops.clear_hw_cntrs(hw);
 393
 394         /* Set No Snoop Disable */
 395         ctrl_ext = IXGBE_READ_REG(hw, IXGBE_CTRL_EXT);
 396         ctrl_ext |= IXGBE_CTRL_EXT_NS_DIS;
 397         IXGBE_WRITE_REG(hw, IXGBE_CTRL_EXT, ctrl_ext);
 398         IXGBE_WRITE_FLUSH(hw);
 399
 400         /* Setup flow control */
 401         ret_val = ixgbe_setup_fc(hw);
 402         if (ret_val != IXGBE_SUCCESS)
 403                 goto out;
 404
 405         /* Clear adapter stopped flag */
 406         hw->adapter_stopped = FALSE;
 407
 408 out:
 409         return ret_val;
 410 }
 411
 412 /**
 413  *  ixgbe_start_hw_gen2 - Init sequence for common device family
 414  *  @hw: pointer to hw structure
 415  *
 416  * Performs the init sequence common to the second generation
 417  * of 10 GbE devices.
 418  * Devices in the second generation:
 419  *     82599
 420  *     X540
 421  **/
 422 s32 ixgbe_start_hw_gen2(struct ixgbe_hw *hw)
 423 {
 424         u32 i;
 425         u32 regval;
 426
 427         /* Clear the rate limiters */
 428         for (i = 0; i < hw->mac.max_tx_queues; i++) {
 429                 IXGBE_WRITE_REG(hw, IXGBE_RTTDQSEL, i);
 430                 IXGBE_WRITE_REG(hw, IXGBE_RTTBCNRC, 0);
 431         }
 432         IXGBE_WRITE_FLUSH(hw);
 433
 434         /* Disable relaxed ordering */
 435         for (i = 0; i < hw->mac.max_tx_queues; i++) {
 436                 regval = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL_82599(i));
 437                 regval &= ~IXGBE_DCA_TXCTRL_DESC_WRO_EN;
 438                 IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL_82599(i), regval);
 439         }
 440
 441         for (i = 0; i < hw->mac.max_rx_queues; i++) {
 442                 regval = IXGBE_READ_REG(hw, IXGBE_DCA_RXCTRL(i));
 443                 regval &= ~(IXGBE_DCA_RXCTRL_DATA_WRO_EN |
 444                             IXGBE_DCA_RXCTRL_HEAD_WRO_EN);
 445                 IXGBE_WRITE_REG(hw, IXGBE_DCA_RXCTRL(i), regval);
 446         }
 447
 448         return IXGBE_SUCCESS;
 449 }
 450
 451 /**
 452  *  ixgbe_init_hw_generic - Generic hardware initialization
 453  *  @hw: pointer to hardware structure
 454  *
 455  *  Initialize the hardware by resetting the hardware, filling the bus info
 456  *  structure and media type, clears all on chip counters, initializes receive
 457  *  address registers, multicast table, VLAN filter table, calls routine to set
 458  *  up link and flow control settings, and leaves transmit and receive units
 459  *  disabled and uninitialized
 460  **/
 461 s32 ixgbe_init_hw_generic(struct ixgbe_hw *hw)
 462 {
 463         s32 status;
 464
 465         DEBUGFUNC("ixgbe_init_hw_generic");
 466
 467         /* Reset the hardware */
 468         status = hw->mac.ops.reset_hw(hw);
 469
 470         if (status == IXGBE_SUCCESS) {
 471                 /* Start the HW */
 472                 status = hw->mac.ops.start_hw(hw);
 473         }
 474
 475         return status;
 476 }
 477
 478 /**
 479  *  ixgbe_clear_hw_cntrs_generic - Generic clear hardware counters
 480  *  @hw: pointer to hardware structure
 481  *
 482  *  Clears all hardware statistics counters by reading them from the hardware
 483  *  Statistics counters are clear on read.
 484  **/
 485 s32 ixgbe_clear_hw_cntrs_generic(struct ixgbe_hw *hw)
 486 {
 487         u16 i = 0;
 488
 489         DEBUGFUNC("ixgbe_clear_hw_cntrs_generic");
 490
 491         IXGBE_READ_REG(hw, IXGBE_CRCERRS);
 492         IXGBE_READ_REG(hw, IXGBE_ILLERRC);
 493         IXGBE_READ_REG(hw, IXGBE_ERRBC);
 494         IXGBE_READ_REG(hw, IXGBE_MSPDC);
 495         for (i = 0; i < 8; i++)
 496                 IXGBE_READ_REG(hw, IXGBE_MPC(i));
 497
 498         IXGBE_READ_REG(hw, IXGBE_MLFC);
 499         IXGBE_READ_REG(hw, IXGBE_MRFC);
 500         IXGBE_READ_REG(hw, IXGBE_RLEC);
 501         IXGBE_READ_REG(hw, IXGBE_LXONTXC);
 502         IXGBE_READ_REG(hw, IXGBE_LXOFFTXC);
 503         if (hw->mac.type >= ixgbe_mac_82599EB) {
 504                 IXGBE_READ_REG(hw, IXGBE_LXONRXCNT);
 505                 IXGBE_READ_REG(hw, IXGBE_LXOFFRXCNT);
 506         } else {
 507                 IXGBE_READ_REG(hw, IXGBE_LXONRXC);
 508                 IXGBE_READ_REG(hw, IXGBE_LXOFFRXC);
 509         }
 510
 511         for (i = 0; i < 8; i++) {
 512                 IXGBE_READ_REG(hw, IXGBE_PXONTXC(i));
 513                 IXGBE_READ_REG(hw, IXGBE_PXOFFTXC(i));
 514                 if (hw->mac.type >= ixgbe_mac_82599EB) {
 515                         IXGBE_READ_REG(hw, IXGBE_PXONRXCNT(i));
 516                         IXGBE_READ_REG(hw, IXGBE_PXOFFRXCNT(i));
 517                 } else {
 518                         IXGBE_READ_REG(hw, IXGBE_PXONRXC(i));
 519                         IXGBE_READ_REG(hw, IXGBE_PXOFFRXC(i));
 520                 }
 521         }
 522         if (hw->mac.type >= ixgbe_mac_82599EB)
 523                 for (i = 0; i < 8; i++)
 524                         IXGBE_READ_REG(hw, IXGBE_PXON2OFFCNT(i));
 525         IXGBE_READ_REG(hw, IXGBE_PRC64);
 526         IXGBE_READ_REG(hw, IXGBE_PRC127);
 527         IXGBE_READ_REG(hw, IXGBE_PRC255);
 528         IXGBE_READ_REG(hw, IXGBE_PRC511);
 529         IXGBE_READ_REG(hw, IXGBE_PRC1023);
 530         IXGBE_READ_REG(hw, IXGBE_PRC1522);
 531         IXGBE_READ_REG(hw, IXGBE_GPRC);
 532         IXGBE_READ_REG(hw, IXGBE_BPRC);
 533         IXGBE_READ_REG(hw, IXGBE_MPRC);
 534         IXGBE_READ_REG(hw, IXGBE_GPTC);
 535         IXGBE_READ_REG(hw, IXGBE_GORCL);
 536         IXGBE_READ_REG(hw, IXGBE_GORCH);
 537         IXGBE_READ_REG(hw, IXGBE_GOTCL);
 538         IXGBE_READ_REG(hw, IXGBE_GOTCH);
 539         if (hw->mac.type == ixgbe_mac_82598EB)
 540                 for (i = 0; i < 8; i++)
 541                         IXGBE_READ_REG(hw, IXGBE_RNBC(i));
 542         IXGBE_READ_REG(hw, IXGBE_RUC);
 543         IXGBE_READ_REG(hw, IXGBE_RFC);
 544         IXGBE_READ_REG(hw, IXGBE_ROC);
 545         IXGBE_READ_REG(hw, IXGBE_RJC);
 546         IXGBE_READ_REG(hw, IXGBE_MNGPRC);
 547         IXGBE_READ_REG(hw, IXGBE_MNGPDC);
 548         IXGBE_READ_REG(hw, IXGBE_MNGPTC);
 549         IXGBE_READ_REG(hw, IXGBE_TORL);
 550         IXGBE_READ_REG(hw, IXGBE_TORH);
 551         IXGBE_READ_REG(hw, IXGBE_TPR);
 552         IXGBE_READ_REG(hw, IXGBE_TPT);
 553         IXGBE_READ_REG(hw, IXGBE_PTC64);
 554         IXGBE_READ_REG(hw, IXGBE_PTC127);
 555         IXGBE_READ_REG(hw, IXGBE_PTC255);
 556         IXGBE_READ_REG(hw, IXGBE_PTC511);
 557         IXGBE_READ_REG(hw, IXGBE_PTC1023);
 558         IXGBE_READ_REG(hw, IXGBE_PTC1522);
 559         IXGBE_READ_REG(hw, IXGBE_MPTC);
 560         IXGBE_READ_REG(hw, IXGBE_BPTC);
 561         for (i = 0; i < 16; i++) {
 562                 IXGBE_READ_REG(hw, IXGBE_QPRC(i));
 563                 IXGBE_READ_REG(hw, IXGBE_QPTC(i));
 564                 if (hw->mac.type >= ixgbe_mac_82599EB) {
 565                         IXGBE_READ_REG(hw, IXGBE_QBRC_L(i));
 566                         IXGBE_READ_REG(hw, IXGBE_QBRC_H(i));
 567                         IXGBE_READ_REG(hw, IXGBE_QBTC_L(i));
 568                         IXGBE_READ_REG(hw, IXGBE_QBTC_H(i));
 569                         IXGBE_READ_REG(hw, IXGBE_QPRDC(i));
 570                 } else {
 571                         IXGBE_READ_REG(hw, IXGBE_QBRC(i));
 572                         IXGBE_READ_REG(hw, IXGBE_QBTC(i));
 573                 }
 574         }
 575
 576         if (hw->mac.type == ixgbe_mac_X550 || hw->mac.type == ixgbe_mac_X540) {
 577                 if (hw->phy.id == 0)
 578                         ixgbe_identify_phy(hw);
 579                 hw->phy.ops.read_reg(hw, IXGBE_PCRC8ECL,
 580                                      IXGBE_MDIO_PCS_DEV_TYPE, &i);
 581                 hw->phy.ops.read_reg(hw, IXGBE_PCRC8ECH,
 582                                      IXGBE_MDIO_PCS_DEV_TYPE, &i);
 583                 hw->phy.ops.read_reg(hw, IXGBE_LDPCECL,
 584                                      IXGBE_MDIO_PCS_DEV_TYPE, &i);
 585                 hw->phy.ops.read_reg(hw, IXGBE_LDPCECH,
 586                                      IXGBE_MDIO_PCS_DEV_TYPE, &i);
 587         }
 588
 589         return IXGBE_SUCCESS;
 590 }
 591
 592 /**
 593  *  ixgbe_read_pba_string_generic - Reads part number string from EEPROM
 594  *  @hw: pointer to hardware structure
 595  *  @pba_num: stores the part number string from the EEPROM
 596  *  @pba_num_size: part number string buffer length
 597  *
 598  *  Reads the part number string from the EEPROM.
 599  **/
 600 s32 ixgbe_read_pba_string_generic(struct ixgbe_hw *hw, u8 *pba_num,
 601                                   u32 pba_num_size)
 602 {
 603         s32 ret_val;
 604         u16 data;
 605         u16 pba_ptr;
 606         u16 offset;
 607         u16 length;
 608
 609         DEBUGFUNC("ixgbe_read_pba_string_generic");
 610
 611         if (pba_num == NULL) {
 612                 DEBUGOUT("PBA string buffer was null\n");
 613                 return IXGBE_ERR_INVALID_ARGUMENT;
 614         }
 615
 616         ret_val = hw->eeprom.ops.read(hw, IXGBE_PBANUM0_PTR, &data);
 617         if (ret_val) {
 618                 DEBUGOUT("NVM Read Error\n");
 619                 return ret_val;
 620         }
 621
 622         ret_val = hw->eeprom.ops.read(hw, IXGBE_PBANUM1_PTR, &pba_ptr);
 623         if (ret_val) {
 624                 DEBUGOUT("NVM Read Error\n");
 625                 return ret_val;
 626         }
 627
 628         /*
 629          * if data is not ptr guard the PBA must be in legacy format which
 630          * means pba_ptr is actually our second data word for the PBA number
 631          * and we can decode it into an ascii string
 632          */
 633         if (data != IXGBE_PBANUM_PTR_GUARD) {
 634                 DEBUGOUT("NVM PBA number is not stored as string\n");
 635
 636                 /* we will need 11 characters to store the PBA */
 637                 if (pba_num_size < 11) {
 638                         DEBUGOUT("PBA string buffer too small\n");
 639                         return IXGBE_ERR_NO_SPACE;
 640                 }
 641
 642                 /* extract hex string from data and pba_ptr */
 643                 pba_num[0] = (data >> 12) & 0xF;
 644                 pba_num[1] = (data >> 8) & 0xF;
 645                 pba_num[2] = (data >> 4) & 0xF;
 646                 pba_num[3] = data & 0xF;
 647                 pba_num[4] = (pba_ptr >> 12) & 0xF;
 648                 pba_num[5] = (pba_ptr >> 8) & 0xF;
 649                 pba_num[6] = '-';
 650                 pba_num[7] = 0;
 651                 pba_num[8] = (pba_ptr >> 4) & 0xF;
 652                 pba_num[9] = pba_ptr & 0xF;
 653
 654                 /* put a null character on the end of our string */
 655                 pba_num[10] = '\0';
 656
 657                 /* switch all the data but the '-' to hex char */
 658                 for (offset = 0; offset < 10; offset++) {
 659                         if (pba_num[offset] < 0xA)
 660                                 pba_num[offset] += '0';
 661                         else if (pba_num[offset] < 0x10)
 662                                 pba_num[offset] += 'A' - 0xA;
 663                 }
 664
 665                 return IXGBE_SUCCESS;
 666         }
 667
 668         ret_val = hw->eeprom.ops.read(hw, pba_ptr, &length);
 669         if (ret_val) {
 670                 DEBUGOUT("NVM Read Error\n");
 671                 return ret_val;
 672         }
 673
 674         if (length == 0xFFFF || length == 0) {
 675                 DEBUGOUT("NVM PBA number section invalid length\n");
 676                 return IXGBE_ERR_PBA_SECTION;
 677         }
 678
 679         /* check if pba_num buffer is big enough */
 680         if (pba_num_size  < (((u32)length * 2) - 1)) {
 681                 DEBUGOUT("PBA string buffer too small\n");
 682                 return IXGBE_ERR_NO_SPACE;
 683         }
 684
 685         /* trim pba length from start of string */
 686         pba_ptr++;
 687         length--;
 688
 689         for (offset = 0; offset < length; offset++) {
 690                 ret_val = hw->eeprom.ops.read(hw, pba_ptr + offset, &data);
 691                 if (ret_val) {
 692                         DEBUGOUT("NVM Read Error\n");
 693                         return ret_val;
 694                 }
 695                 pba_num[offset * 2] = (u8)(data >> 8);
 696                 pba_num[(offset * 2) + 1] = (u8)(data & 0xFF);
 697         }
 698         pba_num[offset * 2] = '\0';
 699
 700         return IXGBE_SUCCESS;
 701 }
 702
 703 /**
 704  *  ixgbe_read_pba_num_generic - Reads part number from EEPROM
 705  *  @hw: pointer to hardware structure
 706  *  @pba_num: stores the part number from the EEPROM
 707  *
 708  *  Reads the part number from the EEPROM.
 709  **/
 710 s32 ixgbe_read_pba_num_generic(struct ixgbe_hw *hw, u32 *pba_num)
 711 {
 712         s32 ret_val;
 713         u16 data;
 714
 715         DEBUGFUNC("ixgbe_read_pba_num_generic");
 716
 717         ret_val = hw->eeprom.ops.read(hw, IXGBE_PBANUM0_PTR, &data);
 718         if (ret_val) {
 719                 DEBUGOUT("NVM Read Error\n");
 720                 return ret_val;
 721         } else if (data == IXGBE_PBANUM_PTR_GUARD) {
 722                 DEBUGOUT("NVM Not supported\n");
 723                 return IXGBE_NOT_IMPLEMENTED;
 724         }
 725         *pba_num = (u32)(data << 16);
 726
 727         ret_val = hw->eeprom.ops.read(hw, IXGBE_PBANUM1_PTR, &data);
 728         if (ret_val) {
 729                 DEBUGOUT("NVM Read Error\n");
 730                 return ret_val;
 731         }
 732         *pba_num |= data;
 733
 734         return IXGBE_SUCCESS;
 735 }
 736
 737 /**
 738  *  ixgbe_read_pba_raw
 739  *  @hw: pointer to the HW structure
 740  *  @eeprom_buf: optional pointer to EEPROM image
 741  *  @eeprom_buf_size: size of EEPROM image in words
 742  *  @max_pba_block_size: PBA block size limit
 743  *  @pba: pointer to output PBA structure
 744  *
 745  *  Reads PBA from EEPROM image when eeprom_buf is not NULL.
 746  *  Reads PBA from physical EEPROM device when eeprom_buf is NULL.
 747  *
 748  **/
 749 s32 ixgbe_read_pba_raw(struct ixgbe_hw *hw, u16 *eeprom_buf,
 750                        u32 eeprom_buf_size, u16 max_pba_block_size,
 751                        struct ixgbe_pba *pba)
 752 {
 753         s32 ret_val;
 754         u16 pba_block_size;
 755
 756         if (pba == NULL)
 757                 return IXGBE_ERR_PARAM;
 758
 759         if (eeprom_buf == NULL) {
 760                 ret_val = hw->eeprom.ops.read_buffer(hw, IXGBE_PBANUM0_PTR, 2,
 761                                                      &pba->word[0]);
 762                 if (ret_val)
 763                         return ret_val;
 764         } else {
 765                 if (eeprom_buf_size > IXGBE_PBANUM1_PTR) {
 766                         pba->word[0] = eeprom_buf[IXGBE_PBANUM0_PTR];
 767                         pba->word[1] = eeprom_buf[IXGBE_PBANUM1_PTR];
 768                 } else {
 769                         return IXGBE_ERR_PARAM;
 770                 }
 771         }
 772
 773         if (pba->word[0] == IXGBE_PBANUM_PTR_GUARD) {
 774                 if (pba->pba_block == NULL)
 775                         return IXGBE_ERR_PARAM;
 776
 777                 ret_val = ixgbe_get_pba_block_size(hw, eeprom_buf,
 778                                                    eeprom_buf_size,
 779                                                    &pba_block_size);
 780                 if (ret_val)
 781                         return ret_val;
 782
 783                 if (pba_block_size > max_pba_block_size)
 784                         return IXGBE_ERR_PARAM;
 785
 786                 if (eeprom_buf == NULL) {
 787                         ret_val = hw->eeprom.ops.read_buffer(hw, pba->word[1],
 788                                                              pba_block_size,
 789                                                              pba->pba_block);
 790                         if (ret_val)
 791                                 return ret_val;
 792                 } else {
 793                         if (eeprom_buf_size > (u32)(pba->word[1] +
 794                                               pba_block_size)) {
 795                                 memcpy(pba->pba_block,
 796                                        &eeprom_buf[pba->word[1]],
 797                                        pba_block_size * sizeof(u16));
 798                         } else {
 799                                 return IXGBE_ERR_PARAM;
 800                         }
 801                 }
 802         }
 803
 804         return IXGBE_SUCCESS;
 805 }
 806
 807 /**
 808  *  ixgbe_write_pba_raw
 809  *  @hw: pointer to the HW structure
 810  *  @eeprom_buf: optional pointer to EEPROM image
 811  *  @eeprom_buf_size: size of EEPROM image in words
 812  *  @pba: pointer to PBA structure
 813  *
 814  *  Writes PBA to EEPROM image when eeprom_buf is not NULL.
 815  *  Writes PBA to physical EEPROM device when eeprom_buf is NULL.
 816  *
 817  **/
 818 s32 ixgbe_write_pba_raw(struct ixgbe_hw *hw, u16 *eeprom_buf,
 819                         u32 eeprom_buf_size, struct ixgbe_pba *pba)
 820 {
 821         s32 ret_val;
 822
 823         if (pba == NULL)
 824                 return IXGBE_ERR_PARAM;
 825
 826         if (eeprom_buf == NULL) {
 827                 ret_val = hw->eeprom.ops.write_buffer(hw, IXGBE_PBANUM0_PTR, 2,
 828                                                       &pba->word[0]);
 829                 if (ret_val)
 830                         return ret_val;
 831         } else {
 832                 if (eeprom_buf_size > IXGBE_PBANUM1_PTR) {
 833                         eeprom_buf[IXGBE_PBANUM0_PTR] = pba->word[0];
 834                         eeprom_buf[IXGBE_PBANUM1_PTR] = pba->word[1];
 835                 } else {
 836                         return IXGBE_ERR_PARAM;
 837                 }
 838         }
 839
 840         if (pba->word[0] == IXGBE_PBANUM_PTR_GUARD) {
 841                 if (pba->pba_block == NULL)
 842                         return IXGBE_ERR_PARAM;
 843
 844                 if (eeprom_buf == NULL) {
 845                         ret_val = hw->eeprom.ops.write_buffer(hw, pba->word[1],
 846                                                               pba->pba_block[0],
 847                                                               pba->pba_block);
 848                         if (ret_val)
 849                                 return ret_val;
 850                 } else {
 851                         if (eeprom_buf_size > (u32)(pba->word[1] +
 852                                               pba->pba_block[0])) {
 853                                 memcpy(&eeprom_buf[pba->word[1]],
 854                                        pba->pba_block,
 855                                        pba->pba_block[0] * sizeof(u16));
 856                         } else {
 857                                 return IXGBE_ERR_PARAM;
 858                         }
 859                 }
 860         }
 861
 862         return IXGBE_SUCCESS;
 863 }
 864
 865 /**
 866  *  ixgbe_get_pba_block_size
 867  *  @hw: pointer to the HW structure
 868  *  @eeprom_buf: optional pointer to EEPROM image
 869  *  @eeprom_buf_size: size of EEPROM image in words
 870  *  @pba_data_size: pointer to output variable
 871  *
 872  *  Returns the size of the PBA block in words. Function operates on EEPROM
 873  *  image if the eeprom_buf pointer is not NULL otherwise it accesses physical
 874  *  EEPROM device.
 875  *
 876  **/
 877 s32 ixgbe_get_pba_block_size(struct ixgbe_hw *hw, u16 *eeprom_buf,
 878                              u32 eeprom_buf_size, u16 *pba_block_size)
 879 {
 880         s32 ret_val;
 881         u16 pba_word[2];
 882         u16 length;
 883
 884         DEBUGFUNC("ixgbe_get_pba_block_size");
 885
 886         if (eeprom_buf == NULL) {
 887                 ret_val = hw->eeprom.ops.read_buffer(hw, IXGBE_PBANUM0_PTR, 2,
 888                                                      &pba_word[0]);
 889                 if (ret_val)
 890                         return ret_val;
 891         } else {
 892                 if (eeprom_buf_size > IXGBE_PBANUM1_PTR) {
 893                         pba_word[0] = eeprom_buf[IXGBE_PBANUM0_PTR];
 894                         pba_word[1] = eeprom_buf[IXGBE_PBANUM1_PTR];
 895                 } else {
 896                         return IXGBE_ERR_PARAM;
 897                 }
 898         }
 899
 900         if (pba_word[0] == IXGBE_PBANUM_PTR_GUARD) {
 901                 if (eeprom_buf == NULL) {
 902                         ret_val = hw->eeprom.ops.read(hw, pba_word[1] + 0,
 903                                                       &length);
 904                         if (ret_val)
 905                                 return ret_val;
 906                 } else {
 907                         if (eeprom_buf_size > pba_word[1])
 908                                 length = eeprom_buf[pba_word[1] + 0];
 909                         else
 910                                 return IXGBE_ERR_PARAM;
 911                 }
 912
 913                 if (length == 0xFFFF || length == 0)
 914                         return IXGBE_ERR_PBA_SECTION;
 915         } else {
 916                 /* PBA number in legacy format, there is no PBA Block. */
 917                 length = 0;
 918         }
 919
 920         if (pba_block_size != NULL)
 921                 *pba_block_size = length;
 922
 923         return IXGBE_SUCCESS;
 924 }
 925
 926 /**
 927  *  ixgbe_get_mac_addr_generic - Generic get MAC address
 928  *  @hw: pointer to hardware structure
 929  *  @mac_addr: Adapter MAC address
 930  *
 931  *  Reads the adapter's MAC address from first Receive Address Register (RAR0)
 932  *  A reset of the adapter must be performed prior to calling this function
 933  *  in order for the MAC address to have been loaded from the EEPROM into RAR0
 934  **/
 935 s32 ixgbe_get_mac_addr_generic(struct ixgbe_hw *hw, u8 *mac_addr)
 936 {
 937         u32 rar_high;
 938         u32 rar_low;
 939         u16 i;
 940
 941         DEBUGFUNC("ixgbe_get_mac_addr_generic");
 942
 943         rar_high = IXGBE_READ_REG(hw, IXGBE_RAH(0));
 944         rar_low = IXGBE_READ_REG(hw, IXGBE_RAL(0));
 945
 946         for (i = 0; i < 4; i++)
 947                 mac_addr[i] = (u8)(rar_low >> (i*8));
 948
 949         for (i = 0; i < 2; i++)
 950                 mac_addr[i+4] = (u8)(rar_high >> (i*8));
 951
 952         return IXGBE_SUCCESS;
 953 }
 954
 955 /**
 956  *  ixgbe_set_pci_config_data_generic - Generic store PCI bus info
 957  *  @hw: pointer to hardware structure
 958  *  @link_status: the link status returned by the PCI config space
 959  *
 960  *  Stores the PCI bus info (speed, width, type) within the ixgbe_hw structure
 961  **/
 962 void ixgbe_set_pci_config_data_generic(struct ixgbe_hw *hw, u16 link_status)
 963 {
 964         struct ixgbe_mac_info *mac = &hw->mac;
 965
 966         if (hw->bus.type == ixgbe_bus_type_unknown)
 967                 hw->bus.type = ixgbe_bus_type_pci_express;
 968
 969         switch (link_status & IXGBE_PCI_LINK_WIDTH) {
 970         case IXGBE_PCI_LINK_WIDTH_1:
 971                 hw->bus.width = ixgbe_bus_width_pcie_x1;
 972                 break;
 973         case IXGBE_PCI_LINK_WIDTH_2:
 974                 hw->bus.width = ixgbe_bus_width_pcie_x2;
 975                 break;
 976         case IXGBE_PCI_LINK_WIDTH_4:
 977                 hw->bus.width = ixgbe_bus_width_pcie_x4;
 978                 break;
 979         case IXGBE_PCI_LINK_WIDTH_8:
 980                 hw->bus.width = ixgbe_bus_width_pcie_x8;
 981                 break;
 982         default:
 983                 hw->bus.width = ixgbe_bus_width_unknown;
 984                 break;
 985         }
 986
 987         switch (link_status & IXGBE_PCI_LINK_SPEED) {
 988         case IXGBE_PCI_LINK_SPEED_2500:
 989                 hw->bus.speed = ixgbe_bus_speed_2500;
 990                 break;
 991         case IXGBE_PCI_LINK_SPEED_5000:
 992                 hw->bus.speed = ixgbe_bus_speed_5000;
 993                 break;
 994         case IXGBE_PCI_LINK_SPEED_8000:
 995                 hw->bus.speed = ixgbe_bus_speed_8000;
 996                 break;
 997         default:
 998                 hw->bus.speed = ixgbe_bus_speed_unknown;
 999                 break;
1000         }
1001
1002         mac->ops.set_lan_id(hw);
1003 }
1004
1005 /**
1006  *  ixgbe_get_bus_info_generic - Generic set PCI bus info
1007  *  @hw: pointer to hardware structure
1008  *
1009  *  Gets the PCI bus info (speed, width, type) then calls helper function to
1010  *  store this data within the ixgbe_hw structure.
1011  **/
1012 s32 ixgbe_get_bus_info_generic(struct ixgbe_hw *hw)
1013 {
1014         u16 link_status;
1015
1016         DEBUGFUNC("ixgbe_get_bus_info_generic");
1017
1018         /* Get the negotiated link width and speed from PCI config space */
1019         link_status = IXGBE_READ_PCIE_WORD(hw, IXGBE_PCI_LINK_STATUS);
1020
1021         ixgbe_set_pci_config_data_generic(hw, link_status);
1022
1023         return IXGBE_SUCCESS;
1024 }
1025
1026 /**
1027  *  ixgbe_set_lan_id_multi_port_pcie - Set LAN id for PCIe multiple port devices
1028  *  @hw: pointer to the HW structure
1029  *
1030  *  Determines the LAN function id by reading memory-mapped registers
1031  *  and swaps the port value if requested.
1032  **/
1033 void ixgbe_set_lan_id_multi_port_pcie(struct ixgbe_hw *hw)
1034 {
1035         struct ixgbe_bus_info *bus = &hw->bus;
1036         u32 reg;
1037
1038         DEBUGFUNC("ixgbe_set_lan_id_multi_port_pcie");
1039
1040         reg = IXGBE_READ_REG(hw, IXGBE_STATUS);
1041         bus->func = (reg & IXGBE_STATUS_LAN_ID) >> IXGBE_STATUS_LAN_ID_SHIFT;
1042         bus->lan_id = bus->func;
1043
1044         /* check for a port swap */
1045         reg = IXGBE_READ_REG(hw, IXGBE_FACTPS_BY_MAC(hw));
1046         if (reg & IXGBE_FACTPS_LFS)
1047                 bus->func ^= 0x1;
1048 }
1049
1050 /**
1051  *  ixgbe_stop_adapter_generic - Generic stop Tx/Rx units
1052  *  @hw: pointer to hardware structure
1053  *
1054  *  Sets the adapter_stopped flag within ixgbe_hw struct. Clears interrupts,
1055  *  disables transmit and receive units. The adapter_stopped flag is used by
1056  *  the shared code and drivers to determine if the adapter is in a stopped
1057  *  state and should not touch the hardware.
1058  **/
1059 s32 ixgbe_stop_adapter_generic(struct ixgbe_hw *hw)
1060 {
1061         u32 reg_val;
1062         u16 i;
1063
1064         DEBUGFUNC("ixgbe_stop_adapter_generic");
1065
1066         /*
1067          * Set the adapter_stopped flag so other driver functions stop touching
1068          * the hardware
1069          */
1070         hw->adapter_stopped = TRUE;
1071
1072         /* Disable the receive unit */
1073         ixgbe_disable_rx(hw);
1074
1075         /* Clear interrupt mask to stop interrupts from being generated */
1076         IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_IRQ_CLEAR_MASK);
1077
1078         /* Clear any pending interrupts, flush previous writes */
1079         IXGBE_READ_REG(hw, IXGBE_EICR);
1080
1081         /* Disable the transmit unit.  Each queue must be disabled. */
1082         for (i = 0; i < hw->mac.max_tx_queues; i++)
1083                 IXGBE_WRITE_REG(hw, IXGBE_TXDCTL(i), IXGBE_TXDCTL_SWFLSH);
1084
1085         /* Disable the receive unit by stopping each queue */
1086         for (i = 0; i < hw->mac.max_rx_queues; i++) {
1087                 reg_val = IXGBE_READ_REG(hw, IXGBE_RXDCTL(i));
1088                 reg_val &= ~IXGBE_RXDCTL_ENABLE;
1089                 reg_val |= IXGBE_RXDCTL_SWFLSH;
1090                 IXGBE_WRITE_REG(hw, IXGBE_RXDCTL(i), reg_val);
1091         }
1092
1093         /* flush all queues disables */
1094         IXGBE_WRITE_FLUSH(hw);
1095         msec_delay(2);
1096
1097         /*
1098          * Prevent the PCI-E bus from hanging by disabling PCI-E master
1099          * access and verify no pending requests
1100          */
1101         return ixgbe_disable_pcie_master(hw);
1102 }
1103
1104 /**
1105  *  ixgbe_led_on_generic - Turns on the software controllable LEDs.
1106  *  @hw: pointer to hardware structure
1107  *  @index: led number to turn on
1108  **/
1109 s32 ixgbe_led_on_generic(struct ixgbe_hw *hw, u32 index)
1110 {
1111         u32 led_reg = IXGBE_READ_REG(hw, IXGBE_LEDCTL);
1112
1113         DEBUGFUNC("ixgbe_led_on_generic");
1114
1115         /* To turn on the LED, set mode to ON. */
1116         led_reg &= ~IXGBE_LED_MODE_MASK(index);
1117         led_reg |= IXGBE_LED_ON << IXGBE_LED_MODE_SHIFT(index);
1118         IXGBE_WRITE_REG(hw, IXGBE_LEDCTL, led_reg);
1119         IXGBE_WRITE_FLUSH(hw);
1120
1121         return IXGBE_SUCCESS;
1122 }
1123
1124 /**
1125  *  ixgbe_led_off_generic - Turns off the software controllable LEDs.
1126  *  @hw: pointer to hardware structure
1127  *  @index: led number to turn off
1128  **/
1129 s32 ixgbe_led_off_generic(struct ixgbe_hw *hw, u32 index)
1130 {
1131         u32 led_reg = IXGBE_READ_REG(hw, IXGBE_LEDCTL);
1132
1133         DEBUGFUNC("ixgbe_led_off_generic");
1134
1135         /* To turn off the LED, set mode to OFF. */
1136         led_reg &= ~IXGBE_LED_MODE_MASK(index);
1137         led_reg |= IXGBE_LED_OFF << IXGBE_LED_MODE_SHIFT(index);
1138         IXGBE_WRITE_REG(hw, IXGBE_LEDCTL, led_reg);
1139         IXGBE_WRITE_FLUSH(hw);
1140
1141         return IXGBE_SUCCESS;
1142 }
1143
1144 /**
1145  *  ixgbe_init_eeprom_params_generic - Initialize EEPROM params
1146  *  @hw: pointer to hardware structure
1147  *
1148  *  Initializes the EEPROM parameters ixgbe_eeprom_info within the
1149  *  ixgbe_hw struct in order to set up EEPROM access.
1150  **/
1151 s32 ixgbe_init_eeprom_params_generic(struct ixgbe_hw *hw)
1152 {
1153         struct ixgbe_eeprom_info *eeprom = &hw->eeprom;
1154         u32 eec;
1155         u16 eeprom_size;
1156
1157         DEBUGFUNC("ixgbe_init_eeprom_params_generic");
1158
1159         if (eeprom->type == ixgbe_eeprom_uninitialized) {
1160                 eeprom->type = ixgbe_eeprom_none;
1161                 /* Set default semaphore delay to 10ms which is a well
1162                  * tested value */
1163                 eeprom->semaphore_delay = 10;
1164                 /* Clear EEPROM page size, it will be initialized as needed */
1165                 eeprom->word_page_size = 0;
1166
1167                 /*
1168                  * Check for EEPROM present first.
1169                  * If not present leave as none
1170                  */
1171                 eec = IXGBE_READ_REG(hw, IXGBE_EEC_BY_MAC(hw));
1172                 if (eec & IXGBE_EEC_PRES) {
1173                         eeprom->type = ixgbe_eeprom_spi;
1174
1175                         /*
1176                          * SPI EEPROM is assumed here.  This code would need to
1177                          * change if a future EEPROM is not SPI.
1178                          */
1179                         eeprom_size = (u16)((eec & IXGBE_EEC_SIZE) >>
1180                                             IXGBE_EEC_SIZE_SHIFT);
1181                         eeprom->word_size = 1 << (eeprom_size +
1182                                              IXGBE_EEPROM_WORD_SIZE_SHIFT);
1183                 }
1184
1185                 if (eec & IXGBE_EEC_ADDR_SIZE)
1186                         eeprom->address_bits = 16;
1187                 else
1188                         eeprom->address_bits = 8;
1189                 DEBUGOUT3("Eeprom params: type = %d, size = %d, address bits: "
1190                           "%d\n", eeprom->type, eeprom->word_size,
1191                           eeprom->address_bits);
1192         }
1193
1194         return IXGBE_SUCCESS;
1195 }
1196
1197 /**
1198  *  ixgbe_write_eeprom_buffer_bit_bang_generic - Write EEPROM using bit-bang
1199  *  @hw: pointer to hardware structure
1200  *  @offset: offset within the EEPROM to write
1201  *  @words: number of word(s)
1202  *  @data: 16 bit word(s) to write to EEPROM
1203  *
1204  *  Reads 16 bit word(s) from EEPROM through bit-bang method
1205  **/
1206 s32 ixgbe_write_eeprom_buffer_bit_bang_generic(struct ixgbe_hw *hw, u16 offset,
1207                                                u16 words, u16 *data)
1208 {
1209         s32 status = IXGBE_SUCCESS;
1210         u16 i, count;
1211
1212         DEBUGFUNC("ixgbe_write_eeprom_buffer_bit_bang_generic");
1213
1214         hw->eeprom.ops.init_params(hw);
1215
1216         if (words == 0) {
1217                 status = IXGBE_ERR_INVALID_ARGUMENT;
1218                 goto out;
1219         }
1220
1221         if (offset + words > hw->eeprom.word_size) {
1222                 status = IXGBE_ERR_EEPROM;
1223                 goto out;
1224         }
1225
1226         /*
1227          * The EEPROM page size cannot be queried from the chip. We do lazy
1228          * initialization. It is worth to do that when we write large buffer.
1229          */
1230         if ((hw->eeprom.word_page_size == 0) &&
1231             (words > IXGBE_EEPROM_PAGE_SIZE_MAX))
1232                 ixgbe_detect_eeprom_page_size_generic(hw, offset);
1233
1234         /*
1235          * We cannot hold synchronization semaphores for too long
1236          * to avoid other entity starvation. However it is more efficient
1237          * to read in bursts than synchronizing access for each word.
1238          */
1239         for (i = 0; i < words; i += IXGBE_EEPROM_RD_BUFFER_MAX_COUNT) {
1240                 count = (words - i) / IXGBE_EEPROM_RD_BUFFER_MAX_COUNT > 0 ?
1241                         IXGBE_EEPROM_RD_BUFFER_MAX_COUNT : (words - i);
1242                 status = ixgbe_write_eeprom_buffer_bit_bang(hw, offset + i,
1243                                                             count, &data[i]);
1244
1245                 if (status != IXGBE_SUCCESS)
1246                         break;
1247         }
1248
1249 out:
1250         return status;
1251 }
1252
1253 /**
1254  *  ixgbe_write_eeprom_buffer_bit_bang - Writes 16 bit word(s) to EEPROM
1255  *  @hw: pointer to hardware structure
1256  *  @offset: offset within the EEPROM to be written to
1257  *  @words: number of word(s)
1258  *  @data: 16 bit word(s) to be written to the EEPROM
1259  *
1260  *  If ixgbe_eeprom_update_checksum is not called after this function, the
1261  *  EEPROM will most likely contain an invalid checksum.
1262  **/
1263 static s32 ixgbe_write_eeprom_buffer_bit_bang(struct ixgbe_hw *hw, u16 offset,
1264                                               u16 words, u16 *data)
1265 {
1266         s32 status;
1267         u16 word;
1268         u16 page_size;
1269         u16 i;
1270         u8 write_opcode = IXGBE_EEPROM_WRITE_OPCODE_SPI;
1271
1272         DEBUGFUNC("ixgbe_write_eeprom_buffer_bit_bang");
1273
1274         /* Prepare the EEPROM for writing  */
1275         status = ixgbe_acquire_eeprom(hw);
1276
1277         if (status == IXGBE_SUCCESS) {
1278                 if (ixgbe_ready_eeprom(hw) != IXGBE_SUCCESS) {
1279                         ixgbe_release_eeprom(hw);
1280                         status = IXGBE_ERR_EEPROM;
1281                 }
1282         }
1283
1284         if (status == IXGBE_SUCCESS) {
1285                 for (i = 0; i < words; i++) {
1286                         ixgbe_standby_eeprom(hw);
1287
1288                         /*  Send the WRITE ENABLE command (8 bit opcode )  */
1289                         ixgbe_shift_out_eeprom_bits(hw,
1290                                                    IXGBE_EEPROM_WREN_OPCODE_SPI,
1291                                                    IXGBE_EEPROM_OPCODE_BITS);
1292
1293                         ixgbe_standby_eeprom(hw);
1294
1295                         /*
1296                          * Some SPI eeproms use the 8th address bit embedded
1297                          * in the opcode
1298                          */
1299                         if ((hw->eeprom.address_bits == 8) &&
1300                             ((offset + i) >= 128))
1301                                 write_opcode |= IXGBE_EEPROM_A8_OPCODE_SPI;
1302
1303                         /* Send the Write command (8-bit opcode + addr) */
1304                         ixgbe_shift_out_eeprom_bits(hw, write_opcode,
1305                                                     IXGBE_EEPROM_OPCODE_BITS);
1306                         ixgbe_shift_out_eeprom_bits(hw, (u16)((offset + i) * 2),
1307                                                     hw->eeprom.address_bits);
1308
1309                         page_size = hw->eeprom.word_page_size;
1310
1311                         /* Send the data in burst via SPI*/
1312                         do {
1313                                 word = data[i];
1314                                 word = (word >> 8) | (word << 8);
1315                                 ixgbe_shift_out_eeprom_bits(hw, word, 16);
1316
1317                                 if (page_size == 0)
1318                                         break;
1319
1320                                 /* do not wrap around page */
1321                                 if (((offset + i) & (page_size - 1)) ==
1322                                     (page_size - 1))
1323                                         break;
1324                         } while (++i < words);
1325
1326                         ixgbe_standby_eeprom(hw);
1327                         msec_delay(10);
1328                 }
1329                 /* Done with writing - release the EEPROM */
1330                 ixgbe_release_eeprom(hw);
1331         }
1332
1333         return status;
1334 }
1335
1336 /**
1337  *  ixgbe_write_eeprom_generic - Writes 16 bit value to EEPROM
1338  *  @hw: pointer to hardware structure
1339  *  @offset: offset within the EEPROM to be written to
1340  *  @data: 16 bit word to be written to the EEPROM
1341  *
1342  *  If ixgbe_eeprom_update_checksum is not called after this function, the
1343  *  EEPROM will most likely contain an invalid checksum.
1344  **/
1345 s32 ixgbe_write_eeprom_generic(struct ixgbe_hw *hw, u16 offset, u16 data)
1346 {
1347         s32 status;
1348
1349         DEBUGFUNC("ixgbe_write_eeprom_generic");
1350
1351         hw->eeprom.ops.init_params(hw);
1352
1353         if (offset >= hw->eeprom.word_size) {
1354                 status = IXGBE_ERR_EEPROM;
1355                 goto out;
1356         }
1357
1358         status = ixgbe_write_eeprom_buffer_bit_bang(hw, offset, 1, &data);
1359
1360 out:
1361         return status;
1362 }
1363
1364 /**
1365  *  ixgbe_read_eeprom_buffer_bit_bang_generic - Read EEPROM using bit-bang
1366  *  @hw: pointer to hardware structure
1367  *  @offset: offset within the EEPROM to be read
1368  *  @data: read 16 bit words(s) from EEPROM
1369  *  @words: number of word(s)
1370  *
1371  *  Reads 16 bit word(s) from EEPROM through bit-bang method
1372  **/
1373 s32 ixgbe_read_eeprom_buffer_bit_bang_generic(struct ixgbe_hw *hw, u16 offset,
1374                                               u16 words, u16 *data)
1375 {
1376         s32 status = IXGBE_SUCCESS;
1377         u16 i, count;
1378
1379         DEBUGFUNC("ixgbe_read_eeprom_buffer_bit_bang_generic");
1380
1381         hw->eeprom.ops.init_params(hw);
1382
1383         if (words == 0) {
1384                 status = IXGBE_ERR_INVALID_ARGUMENT;
1385                 goto out;
1386         }
1387
1388         if (offset + words > hw->eeprom.word_size) {
1389                 status = IXGBE_ERR_EEPROM;
1390                 goto out;
1391         }
1392
1393         /*
1394          * We cannot hold synchronization semaphores for too long
1395          * to avoid other entity starvation. However it is more efficient
1396          * to read in bursts than synchronizing access for each word.
1397          */
1398         for (i = 0; i < words; i += IXGBE_EEPROM_RD_BUFFER_MAX_COUNT) {
1399                 count = (words - i) / IXGBE_EEPROM_RD_BUFFER_MAX_COUNT > 0 ?
1400                         IXGBE_EEPROM_RD_BUFFER_MAX_COUNT : (words - i);
1401
1402                 status = ixgbe_read_eeprom_buffer_bit_bang(hw, offset + i,
1403                                                            count, &data[i]);
1404
1405                 if (status != IXGBE_SUCCESS)
1406                         break;
1407         }
1408
1409 out:
1410         return status;
1411 }
1412
1413 /**
1414  *  ixgbe_read_eeprom_buffer_bit_bang - Read EEPROM using bit-bang
1415  *  @hw: pointer to hardware structure
1416  *  @offset: offset within the EEPROM to be read
1417  *  @words: number of word(s)
1418  *  @data: read 16 bit word(s) from EEPROM
1419  *
1420  *  Reads 16 bit word(s) from EEPROM through bit-bang method
1421  **/
1422 static s32 ixgbe_read_eeprom_buffer_bit_bang(struct ixgbe_hw *hw, u16 offset,
1423                                              u16 words, u16 *data)
1424 {
1425         s32 status;
1426         u16 word_in;
1427         u8 read_opcode = IXGBE_EEPROM_READ_OPCODE_SPI;
1428         u16 i;
1429
1430         DEBUGFUNC("ixgbe_read_eeprom_buffer_bit_bang");
1431
1432         /* Prepare the EEPROM for reading  */
1433         status = ixgbe_acquire_eeprom(hw);
1434
1435         if (status == IXGBE_SUCCESS) {
1436                 if (ixgbe_ready_eeprom(hw) != IXGBE_SUCCESS) {
1437                         ixgbe_release_eeprom(hw);
1438                         status = IXGBE_ERR_EEPROM;
1439                 }
1440         }
1441
1442         if (status == IXGBE_SUCCESS) {
1443                 for (i = 0; i < words; i++) {
1444                         ixgbe_standby_eeprom(hw);
1445                         /*
1446                          * Some SPI eeproms use the 8th address bit embedded
1447                          * in the opcode
1448                          */
1449                         if ((hw->eeprom.address_bits == 8) &&
1450                             ((offset + i) >= 128))
1451                                 read_opcode |= IXGBE_EEPROM_A8_OPCODE_SPI;
1452
1453                         /* Send the READ command (opcode + addr) */
1454                         ixgbe_shift_out_eeprom_bits(hw, read_opcode,
1455                                                     IXGBE_EEPROM_OPCODE_BITS);
1456                         ixgbe_shift_out_eeprom_bits(hw, (u16)((offset + i) * 2),
1457                                                     hw->eeprom.address_bits);
1458
1459                         /* Read the data. */
1460                         word_in = ixgbe_shift_in_eeprom_bits(hw, 16);
1461                         data[i] = (word_in >> 8) | (word_in << 8);
1462                 }
1463
1464                 /* End this read operation */
1465                 ixgbe_release_eeprom(hw);
1466         }
1467
1468         return status;
1469 }
1470
1471 /**
1472  *  ixgbe_read_eeprom_bit_bang_generic - Read EEPROM word using bit-bang
1473  *  @hw: pointer to hardware structure
1474  *  @offset: offset within the EEPROM to be read
1475  *  @data: read 16 bit value from EEPROM
1476  *
1477  *  Reads 16 bit value from EEPROM through bit-bang method
1478  **/
1479 s32 ixgbe_read_eeprom_bit_bang_generic(struct ixgbe_hw *hw, u16 offset,
1480                                        u16 *data)
1481 {
1482         s32 status;
1483
1484         DEBUGFUNC("ixgbe_read_eeprom_bit_bang_generic");
1485
1486         hw->eeprom.ops.init_params(hw);
1487
1488         if (offset >= hw->eeprom.word_size) {
1489                 status = IXGBE_ERR_EEPROM;
1490                 goto out;
1491         }
1492
1493         status = ixgbe_read_eeprom_buffer_bit_bang(hw, offset, 1, data);
1494
1495 out:
1496         return status;
1497 }
1498
1499 /**
1500  *  ixgbe_read_eerd_buffer_generic - Read EEPROM word(s) using EERD
1501  *  @hw: pointer to hardware structure
1502  *  @offset: offset of word in the EEPROM to read
1503  *  @words: number of word(s)
1504  *  @data: 16 bit word(s) from the EEPROM
1505  *
1506  *  Reads a 16 bit word(s) from the EEPROM using the EERD register.
1507  **/
1508 s32 ixgbe_read_eerd_buffer_generic(struct ixgbe_hw *hw, u16 offset,
1509                                    u16 words, u16 *data)
1510 {
1511         u32 eerd;
1512         s32 status = IXGBE_SUCCESS;
1513         u32 i;
1514
1515         DEBUGFUNC("ixgbe_read_eerd_buffer_generic");
1516
1517         hw->eeprom.ops.init_params(hw);
1518
1519         if (words == 0) {
1520                 status = IXGBE_ERR_INVALID_ARGUMENT;
1521                 ERROR_REPORT1(IXGBE_ERROR_ARGUMENT, "Invalid EEPROM words");
1522                 goto out;
1523         }
1524
1525         if (offset >= hw->eeprom.word_size) {
1526                 status = IXGBE_ERR_EEPROM;
1527                 ERROR_REPORT1(IXGBE_ERROR_ARGUMENT, "Invalid EEPROM offset");
1528                 goto out;
1529         }
1530
1531         for (i = 0; i < words; i++) {
1532                 eerd = ((offset + i) << IXGBE_EEPROM_RW_ADDR_SHIFT) |
1533                        IXGBE_EEPROM_RW_REG_START;
1534
1535                 IXGBE_WRITE_REG(hw, IXGBE_EERD, eerd);
1536                 status = ixgbe_poll_eerd_eewr_done(hw, IXGBE_NVM_POLL_READ);
1537
1538                 if (status == IXGBE_SUCCESS) {
1539                         data[i] = (IXGBE_READ_REG(hw, IXGBE_EERD) >>
1540                                    IXGBE_EEPROM_RW_REG_DATA);
1541                 } else {
1542                         DEBUGOUT("Eeprom read timed out\n");
1543                         goto out;
1544                 }
1545         }
1546 out:
1547         return status;
1548 }
1549
1550 /**
1551  *  ixgbe_detect_eeprom_page_size_generic - Detect EEPROM page size
1552  *  @hw: pointer to hardware structure
1553  *  @offset: offset within the EEPROM to be used as a scratch pad
1554  *
1555  *  Discover EEPROM page size by writing marching data at given offset.
1556  *  This function is called only when we are writing a new large buffer
1557  *  at given offset so the data would be overwritten anyway.
1558  **/
1559 static s32 ixgbe_detect_eeprom_page_size_generic(struct ixgbe_hw *hw,
1560                                                  u16 offset)
1561 {
1562         u16 data[IXGBE_EEPROM_PAGE_SIZE_MAX];
1563         s32 status = IXGBE_SUCCESS;
1564         u16 i;
1565
1566         DEBUGFUNC("ixgbe_detect_eeprom_page_size_generic");
1567
1568         for (i = 0; i < IXGBE_EEPROM_PAGE_SIZE_MAX; i++)
1569                 data[i] = i;
1570
1571         hw->eeprom.word_page_size = IXGBE_EEPROM_PAGE_SIZE_MAX;
1572         status = ixgbe_write_eeprom_buffer_bit_bang(hw, offset,
1573                                              IXGBE_EEPROM_PAGE_SIZE_MAX, data);
1574         hw->eeprom.word_page_size = 0;
1575         if (status != IXGBE_SUCCESS)
1576                 goto out;
1577
1578         status = ixgbe_read_eeprom_buffer_bit_bang(hw, offset, 1, data);
1579         if (status != IXGBE_SUCCESS)
1580                 goto out;
1581
1582         /*
1583          * When writing in burst more than the actual page size
1584          * EEPROM address wraps around current page.
1585          */
1586         hw->eeprom.word_page_size = IXGBE_EEPROM_PAGE_SIZE_MAX - data[0];
1587
1588         DEBUGOUT1("Detected EEPROM page size = %d words.",
1589                   hw->eeprom.word_page_size);
1590 out:
1591         return status;
1592 }
1593
1594 /**
1595  *  ixgbe_read_eerd_generic - Read EEPROM word using EERD
1596  *  @hw: pointer to hardware structure
1597  *  @offset: offset of  word in the EEPROM to read
1598  *  @data: word read from the EEPROM
1599  *
1600  *  Reads a 16 bit word from the EEPROM using the EERD register.
1601  **/
1602 s32 ixgbe_read_eerd_generic(struct ixgbe_hw *hw, u16 offset, u16 *data)
1603 {
1604         return ixgbe_read_eerd_buffer_generic(hw, offset, 1, data);
1605 }
1606
1607 /**
1608  *  ixgbe_write_eewr_buffer_generic - Write EEPROM word(s) using EEWR
1609  *  @hw: pointer to hardware structure
1610  *  @offset: offset of  word in the EEPROM to write
1611  *  @words: number of word(s)
1612  *  @data: word(s) write to the EEPROM
1613  *
1614  *  Write a 16 bit word(s) to the EEPROM using the EEWR register.
1615  **/
1616 s32 ixgbe_write_eewr_buffer_generic(struct ixgbe_hw *hw, u16 offset,
1617                                     u16 words, u16 *data)
1618 {
1619         u32 eewr;
1620         s32 status = IXGBE_SUCCESS;
1621         u16 i;
1622
1623         DEBUGFUNC("ixgbe_write_eewr_generic");
1624
1625         hw->eeprom.ops.init_params(hw);
1626
1627         if (words == 0) {
1628                 status = IXGBE_ERR_INVALID_ARGUMENT;
1629                 ERROR_REPORT1(IXGBE_ERROR_ARGUMENT, "Invalid EEPROM words");
1630                 goto out;
1631         }
1632
1633         if (offset >= hw->eeprom.word_size) {
1634                 status = IXGBE_ERR_EEPROM;
1635                 ERROR_REPORT1(IXGBE_ERROR_ARGUMENT, "Invalid EEPROM offset");
1636                 goto out;
1637         }
1638
1639         for (i = 0; i < words; i++) {
1640                 eewr = ((offset + i) << IXGBE_EEPROM_RW_ADDR_SHIFT) |
1641                         (data[i] << IXGBE_EEPROM_RW_REG_DATA) |
1642                         IXGBE_EEPROM_RW_REG_START;
1643
1644                 status = ixgbe_poll_eerd_eewr_done(hw, IXGBE_NVM_POLL_WRITE);
1645                 if (status != IXGBE_SUCCESS) {
1646                         DEBUGOUT("Eeprom write EEWR timed out\n");
1647                         goto out;
1648                 }
1649
1650                 IXGBE_WRITE_REG(hw, IXGBE_EEWR, eewr);
1651
1652                 status = ixgbe_poll_eerd_eewr_done(hw, IXGBE_NVM_POLL_WRITE);
1653                 if (status != IXGBE_SUCCESS) {
1654                         DEBUGOUT("Eeprom write EEWR timed out\n");
1655                         goto out;
1656                 }
1657         }
1658
1659 out:
1660         return status;
1661 }
1662
1663 /**
1664  *  ixgbe_write_eewr_generic - Write EEPROM word using EEWR
1665  *  @hw: pointer to hardware structure
1666  *  @offset: offset of  word in the EEPROM to write
1667  *  @data: word write to the EEPROM
1668  *
1669  *  Write a 16 bit word to the EEPROM using the EEWR register.
1670  **/
1671 s32 ixgbe_write_eewr_generic(struct ixgbe_hw *hw, u16 offset, u16 data)
1672 {
1673         return ixgbe_write_eewr_buffer_generic(hw, offset, 1, &data);
1674 }
1675
1676 /**
1677  *  ixgbe_poll_eerd_eewr_done - Poll EERD read or EEWR write status
1678  *  @hw: pointer to hardware structure
1679  *  @ee_reg: EEPROM flag for polling
1680  *
1681  *  Polls the status bit (bit 1) of the EERD or EEWR to determine when the
1682  *  read or write is done respectively.
1683  **/
1684 s32 ixgbe_poll_eerd_eewr_done(struct ixgbe_hw *hw, u32 ee_reg)
1685 {
1686         u32 i;
1687         u32 reg;
1688         s32 status = IXGBE_ERR_EEPROM;
1689
1690         DEBUGFUNC("ixgbe_poll_eerd_eewr_done");
1691
1692         for (i = 0; i < IXGBE_EERD_EEWR_ATTEMPTS; i++) {
1693                 if (ee_reg == IXGBE_NVM_POLL_READ)
1694                         reg = IXGBE_READ_REG(hw, IXGBE_EERD);
1695                 else
1696                         reg = IXGBE_READ_REG(hw, IXGBE_EEWR);
1697
1698                 if (reg & IXGBE_EEPROM_RW_REG_DONE) {
1699                         status = IXGBE_SUCCESS;
1700                         break;
1701                 }
1702                 usec_delay(5);
1703         }
1704
1705         if (i == IXGBE_EERD_EEWR_ATTEMPTS)
1706                 ERROR_REPORT1(IXGBE_ERROR_POLLING,
1707                              "EEPROM read/write done polling timed out");
1708
1709         return status;
1710 }
1711
1712 /**
1713  *  ixgbe_acquire_eeprom - Acquire EEPROM using bit-bang
1714  *  @hw: pointer to hardware structure
1715  *
1716  *  Prepares EEPROM for access using bit-bang method. This function should
1717  *  be called before issuing a command to the EEPROM.
1718  **/
1719 static s32 ixgbe_acquire_eeprom(struct ixgbe_hw *hw)
1720 {
1721         s32 status = IXGBE_SUCCESS;
1722         u32 eec;
1723         u32 i;
1724
1725         DEBUGFUNC("ixgbe_acquire_eeprom");
1726
1727         if (hw->mac.ops.acquire_swfw_sync(hw, IXGBE_GSSR_EEP_SM)
1728             != IXGBE_SUCCESS)
1729                 status = IXGBE_ERR_SWFW_SYNC;
1730
1731         if (status == IXGBE_SUCCESS) {
1732                 eec = IXGBE_READ_REG(hw, IXGBE_EEC_BY_MAC(hw));
1733
1734                 /* Request EEPROM Access */
1735                 eec |= IXGBE_EEC_REQ;
1736                 IXGBE_WRITE_REG(hw, IXGBE_EEC_BY_MAC(hw), eec);
1737
1738                 for (i = 0; i < IXGBE_EEPROM_GRANT_ATTEMPTS; i++) {
1739                         eec = IXGBE_READ_REG(hw, IXGBE_EEC_BY_MAC(hw));
1740                         if (eec & IXGBE_EEC_GNT)
1741                                 break;
1742                         usec_delay(5);
1743                 }
1744
1745                 /* Release if grant not acquired */
1746                 if (!(eec & IXGBE_EEC_GNT)) {
1747                         eec &= ~IXGBE_EEC_REQ;
1748                         IXGBE_WRITE_REG(hw, IXGBE_EEC_BY_MAC(hw), eec);
1749                         DEBUGOUT("Could not acquire EEPROM grant\n");
1750
1751                         hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_EEP_SM);
1752                         status = IXGBE_ERR_EEPROM;
1753                 }
1754
1755                 /* Setup EEPROM for Read/Write */
1756                 if (status == IXGBE_SUCCESS) {
1757                         /* Clear CS and SK */
1758                         eec &= ~(IXGBE_EEC_CS | IXGBE_EEC_SK);
1759                         IXGBE_WRITE_REG(hw, IXGBE_EEC_BY_MAC(hw), eec);
1760                         IXGBE_WRITE_FLUSH(hw);
1761                         usec_delay(1);
1762                 }
1763         }
1764         return status;
1765 }
1766
1767 /**
1768  *  ixgbe_get_eeprom_semaphore - Get hardware semaphore
1769  *  @hw: pointer to hardware structure
1770  *
1771  *  Sets the hardware semaphores so EEPROM access can occur for bit-bang method
1772  **/
1773 static s32 ixgbe_get_eeprom_semaphore(struct ixgbe_hw *hw)
1774 {
1775         s32 status = IXGBE_ERR_EEPROM;
1776         u32 timeout = 2000;
1777         u32 i;
1778         u32 swsm;
1779
1780         DEBUGFUNC("ixgbe_get_eeprom_semaphore");
1781
1782
1783         /* Get SMBI software semaphore between device drivers first */
1784         for (i = 0; i < timeout; i++) {
1785                 /*
1786                  * If the SMBI bit is 0 when we read it, then the bit will be
1787                  * set and we have the semaphore
1788                  */
1789                 swsm = IXGBE_READ_REG(hw, IXGBE_SWSM_BY_MAC(hw));
1790                 if (!(swsm & IXGBE_SWSM_SMBI)) {
1791                         status = IXGBE_SUCCESS;
1792                         break;
1793                 }
1794                 usec_delay(50);
1795         }
1796
1797         if (i == timeout) {
1798                 DEBUGOUT("Driver can't access the Eeprom - SMBI Semaphore "
1799                          "not granted.\n");
1800                 /*
1801                  * this release is particularly important because our attempts
1802                  * above to get the semaphore may have succeeded, and if there
1803                  * was a timeout, we should unconditionally clear the semaphore
1804                  * bits to free the driver to make progress
1805                  */
1806                 ixgbe_release_eeprom_semaphore(hw);
1807
1808                 usec_delay(50);
1809                 /*
1810                  * one last try
1811                  * If the SMBI bit is 0 when we read it, then the bit will be
1812                  * set and we have the semaphore
1813                  */
1814                 swsm = IXGBE_READ_REG(hw, IXGBE_SWSM_BY_MAC(hw));
1815                 if (!(swsm & IXGBE_SWSM_SMBI))
1816                         status = IXGBE_SUCCESS;
1817         }
1818
1819         /* Now get the semaphore between SW/FW through the SWESMBI bit */
1820         if (status == IXGBE_SUCCESS) {
1821                 for (i = 0; i < timeout; i++) {
1822                         swsm = IXGBE_READ_REG(hw, IXGBE_SWSM_BY_MAC(hw));
1823
1824                         /* Set the SW EEPROM semaphore bit to request access */
1825                         swsm |= IXGBE_SWSM_SWESMBI;
1826                         IXGBE_WRITE_REG(hw, IXGBE_SWSM_BY_MAC(hw), swsm);
1827
1828                         /*
1829                          * If we set the bit successfully then we got the
1830                          * semaphore.
1831                          */
1832                         swsm = IXGBE_READ_REG(hw, IXGBE_SWSM_BY_MAC(hw));
1833                         if (swsm & IXGBE_SWSM_SWESMBI)
1834                                 break;
1835
1836                         usec_delay(50);
1837                 }
1838
1839                 /*
1840                  * Release semaphores and return error if SW EEPROM semaphore
1841                  * was not granted because we don't have access to the EEPROM
1842                  */
1843                 if (i >= timeout) {
1844                         ERROR_REPORT1(IXGBE_ERROR_POLLING,
1845                             "SWESMBI Software EEPROM semaphore not granted.\n");
1846                         ixgbe_release_eeprom_semaphore(hw);
1847                         status = IXGBE_ERR_EEPROM;
1848                 }
1849         } else {
1850                 ERROR_REPORT1(IXGBE_ERROR_POLLING,
1851                              "Software semaphore SMBI between device drivers "
1852                              "not granted.\n");
1853         }
1854
1855         return status;
1856 }
1857
1858 /**
1859  *  ixgbe_release_eeprom_semaphore - Release hardware semaphore
1860  *  @hw: pointer to hardware structure
1861  *
1862  *  This function clears hardware semaphore bits.
1863  **/
1864 static void ixgbe_release_eeprom_semaphore(struct ixgbe_hw *hw)
1865 {
1866         u32 swsm;
1867
1868         DEBUGFUNC("ixgbe_release_eeprom_semaphore");
1869
1870         swsm = IXGBE_READ_REG(hw, IXGBE_SWSM);
1871
1872         /* Release both semaphores by writing 0 to the bits SWESMBI and SMBI */
1873         swsm &= ~(IXGBE_SWSM_SWESMBI | IXGBE_SWSM_SMBI);
1874         IXGBE_WRITE_REG(hw, IXGBE_SWSM, swsm);
1875         IXGBE_WRITE_FLUSH(hw);
1876 }
1877
1878 /**
1879  *  ixgbe_ready_eeprom - Polls for EEPROM ready
1880  *  @hw: pointer to hardware structure
1881  **/
1882 static s32 ixgbe_ready_eeprom(struct ixgbe_hw *hw)
1883 {
1884         s32 status = IXGBE_SUCCESS;
1885         u16 i;
1886         u8 spi_stat_reg;
1887
1888         DEBUGFUNC("ixgbe_ready_eeprom");
1889
1890         /*
1891          * Read "Status Register" repeatedly until the LSB is cleared.  The
1892          * EEPROM will signal that the command has been completed by clearing
1893          * bit 0 of the internal status register.  If it's not cleared within
1894          * 5 milliseconds, then error out.
1895          */
1896         for (i = 0; i < IXGBE_EEPROM_MAX_RETRY_SPI; i += 5) {
1897                 ixgbe_shift_out_eeprom_bits(hw, IXGBE_EEPROM_RDSR_OPCODE_SPI,
1898                                             IXGBE_EEPROM_OPCODE_BITS);
1899                 spi_stat_reg = (u8)ixgbe_shift_in_eeprom_bits(hw, 8);
1900                 if (!(spi_stat_reg & IXGBE_EEPROM_STATUS_RDY_SPI))
1901                         break;
1902
1903                 usec_delay(5);
1904                 ixgbe_standby_eeprom(hw);
1905         };
1906
1907         /*
1908          * On some parts, SPI write time could vary from 0-20mSec on 3.3V
1909          * devices (and only 0-5mSec on 5V devices)
1910          */
1911         if (i >= IXGBE_EEPROM_MAX_RETRY_SPI) {
1912                 DEBUGOUT("SPI EEPROM Status error\n");
1913                 status = IXGBE_ERR_EEPROM;
1914         }
1915
1916         return status;
1917 }
1918
1919 /**
1920  *  ixgbe_standby_eeprom - Returns EEPROM to a "standby" state
1921  *  @hw: pointer to hardware structure
1922  **/
1923 static void ixgbe_standby_eeprom(struct ixgbe_hw *hw)
1924 {
1925         u32 eec;
1926
1927         DEBUGFUNC("ixgbe_standby_eeprom");
1928
1929         eec = IXGBE_READ_REG(hw, IXGBE_EEC_BY_MAC(hw));
1930
1931         /* Toggle CS to flush commands */
1932         eec |= IXGBE_EEC_CS;
1933         IXGBE_WRITE_REG(hw, IXGBE_EEC_BY_MAC(hw), eec);
1934         IXGBE_WRITE_FLUSH(hw);
1935         usec_delay(1);
1936         eec &= ~IXGBE_EEC_CS;
1937         IXGBE_WRITE_REG(hw, IXGBE_EEC_BY_MAC(hw), eec);
1938         IXGBE_WRITE_FLUSH(hw);
1939         usec_delay(1);
1940 }
1941
1942 /**
1943  *  ixgbe_shift_out_eeprom_bits - Shift data bits out to the EEPROM.
1944  *  @hw: pointer to hardware structure
1945  *  @data: data to send to the EEPROM
1946  *  @count: number of bits to shift out
1947  **/
1948 static void ixgbe_shift_out_eeprom_bits(struct ixgbe_hw *hw, u16 data,
1949                                         u16 count)
1950 {
1951         u32 eec;
1952         u32 mask;
1953         u32 i;
1954
1955         DEBUGFUNC("ixgbe_shift_out_eeprom_bits");
1956
1957         eec = IXGBE_READ_REG(hw, IXGBE_EEC_BY_MAC(hw));
1958
1959         /*
1960          * Mask is used to shift "count" bits of "data" out to the EEPROM
1961          * one bit at a time.  Determine the starting bit based on count
1962          */
1963         mask = 0x01 << (count - 1);
1964
1965         for (i = 0; i < count; i++) {
1966                 /*
1967                  * A "1" is shifted out to the EEPROM by setting bit "DI" to a
1968                  * "1", and then raising and then lowering the clock (the SK
1969                  * bit controls the clock input to the EEPROM).  A "0" is
1970                  * shifted out to the EEPROM by setting "DI" to "0" and then
1971                  * raising and then lowering the clock.
1972                  */
1973                 if (data & mask)
1974                         eec |= IXGBE_EEC_DI;
1975                 else
1976                         eec &= ~IXGBE_EEC_DI;
1977
1978                 IXGBE_WRITE_REG(hw, IXGBE_EEC_BY_MAC(hw), eec);
1979                 IXGBE_WRITE_FLUSH(hw);
1980
1981                 usec_delay(1);
1982
1983                 ixgbe_raise_eeprom_clk(hw, &eec);
1984                 ixgbe_lower_eeprom_clk(hw, &eec);
1985
1986                 /*
1987                  * Shift mask to signify next bit of data to shift in to the
1988                  * EEPROM
1989                  */
1990                 mask = mask >> 1;
1991         };
1992
1993         /* We leave the "DI" bit set to "0" when we leave this routine. */
1994         eec &= ~IXGBE_EEC_DI;
1995         IXGBE_WRITE_REG(hw, IXGBE_EEC_BY_MAC(hw), eec);
1996         IXGBE_WRITE_FLUSH(hw);
1997 }
1998
1999 /**
2000  *  ixgbe_shift_in_eeprom_bits - Shift data bits in from the EEPROM
2001  *  @hw: pointer to hardware structure
2002  **/
2003 static u16 ixgbe_shift_in_eeprom_bits(struct ixgbe_hw *hw, u16 count)
2004 {
2005         u32 eec;
2006         u32 i;
2007         u16 data = 0;
2008
2009         DEBUGFUNC("ixgbe_shift_in_eeprom_bits");
2010
2011         /*
2012          * In order to read a register from the EEPROM, we need to shift
2013          * 'count' bits in from the EEPROM. Bits are "shifted in" by raising
2014          * the clock input to the EEPROM (setting the SK bit), and then reading
2015          * the value of the "DO" bit.  During this "shifting in" process the
2016          * "DI" bit should always be clear.
2017          */
2018         eec = IXGBE_READ_REG(hw, IXGBE_EEC_BY_MAC(hw));
2019
2020         eec &= ~(IXGBE_EEC_DO | IXGBE_EEC_DI);
2021
2022         for (i = 0; i < count; i++) {
2023                 data = data << 1;
2024                 ixgbe_raise_eeprom_clk(hw, &eec);
2025
2026                 eec = IXGBE_READ_REG(hw, IXGBE_EEC_BY_MAC(hw));
2027
2028                 eec &= ~(IXGBE_EEC_DI);
2029                 if (eec & IXGBE_EEC_DO)
2030                         data |= 1;
2031
2032                 ixgbe_lower_eeprom_clk(hw, &eec);
2033         }
2034
2035         return data;
2036 }
2037
2038 /**
2039  *  ixgbe_raise_eeprom_clk - Raises the EEPROM's clock input.
2040  *  @hw: pointer to hardware structure
2041  *  @eec: EEC register's current value
2042  **/
2043 static void ixgbe_raise_eeprom_clk(struct ixgbe_hw *hw, u32 *eec)
2044 {
2045         DEBUGFUNC("ixgbe_raise_eeprom_clk");
2046
2047         /*
2048          * Raise the clock input to the EEPROM
2049          * (setting the SK bit), then delay
2050          */
2051         *eec = *eec | IXGBE_EEC_SK;
2052         IXGBE_WRITE_REG(hw, IXGBE_EEC_BY_MAC(hw), *eec);
2053         IXGBE_WRITE_FLUSH(hw);
2054         usec_delay(1);
2055 }
2056
2057 /**
2058  *  ixgbe_lower_eeprom_clk - Lowers the EEPROM's clock input.
2059  *  @hw: pointer to hardware structure
2060  *  @eecd: EECD's current value
2061  **/
2062 static void ixgbe_lower_eeprom_clk(struct ixgbe_hw *hw, u32 *eec)
2063 {
2064         DEBUGFUNC("ixgbe_lower_eeprom_clk");
2065
2066         /*
2067          * Lower the clock input to the EEPROM (clearing the SK bit), then
2068          * delay
2069          */
2070         *eec = *eec & ~IXGBE_EEC_SK;
2071         IXGBE_WRITE_REG(hw, IXGBE_EEC_BY_MAC(hw), *eec);
2072         IXGBE_WRITE_FLUSH(hw);
2073         usec_delay(1);
2074 }
2075
2076 /**
2077  *  ixgbe_release_eeprom - Release EEPROM, release semaphores
2078  *  @hw: pointer to hardware structure
2079  **/
2080 static void ixgbe_release_eeprom(struct ixgbe_hw *hw)
2081 {
2082         u32 eec;
2083
2084         DEBUGFUNC("ixgbe_release_eeprom");
2085
2086         eec = IXGBE_READ_REG(hw, IXGBE_EEC_BY_MAC(hw));
2087
2088         eec |= IXGBE_EEC_CS;  /* Pull CS high */
2089         eec &= ~IXGBE_EEC_SK; /* Lower SCK */
2090
2091         IXGBE_WRITE_REG(hw, IXGBE_EEC_BY_MAC(hw), eec);
2092         IXGBE_WRITE_FLUSH(hw);
2093
2094         usec_delay(1);
2095
2096         /* Stop requesting EEPROM access */
2097         eec &= ~IXGBE_EEC_REQ;
2098         IXGBE_WRITE_REG(hw, IXGBE_EEC_BY_MAC(hw), eec);
2099
2100         hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_EEP_SM);
2101
2102         /* Delay before attempt to obtain semaphore again to allow FW access */
2103         msec_delay(hw->eeprom.semaphore_delay);
2104 }
2105
2106 /**
2107  *  ixgbe_calc_eeprom_checksum_generic - Calculates and returns the checksum
2108  *  @hw: pointer to hardware structure
2109  *
2110  *  Returns a negative error code on error, or the 16-bit checksum
2111  **/
2112 s32 ixgbe_calc_eeprom_checksum_generic(struct ixgbe_hw *hw)
2113 {
2114         u16 i;
2115         u16 j;
2116         u16 checksum = 0;
2117         u16 length = 0;
2118         u16 pointer = 0;
2119         u16 word = 0;
2120
2121         DEBUGFUNC("ixgbe_calc_eeprom_checksum_generic");
2122
2123         /* Include 0x0-0x3F in the checksum */
2124         for (i = 0; i < IXGBE_EEPROM_CHECKSUM; i++) {
2125                 if (hw->eeprom.ops.read(hw, i, &word)) {
2126                         DEBUGOUT("EEPROM read failed\n");
2127                         return IXGBE_ERR_EEPROM;
2128                 }
2129                 checksum += word;
2130         }
2131
2132         /* Include all data from pointers except for the fw pointer */
2133         for (i = IXGBE_PCIE_ANALOG_PTR; i < IXGBE_FW_PTR; i++) {
2134                 if (hw->eeprom.ops.read(hw, i, &pointer)) {
2135                         DEBUGOUT("EEPROM read failed\n");
2136                         return IXGBE_ERR_EEPROM;
2137                 }
2138
2139                 /* If the pointer seems invalid */
2140                 if (pointer == 0xFFFF || pointer == 0)
2141                         continue;
2142
2143                 if (hw->eeprom.ops.read(hw, pointer, &length)) {
2144                         DEBUGOUT("EEPROM read failed\n");
2145                         return IXGBE_ERR_EEPROM;
2146                 }
2147
2148                 if (length == 0xFFFF || length == 0)
2149                         continue;
2150
2151                 for (j = pointer + 1; j <= pointer + length; j++) {
2152                         if (hw->eeprom.ops.read(hw, j, &word)) {
2153                                 DEBUGOUT("EEPROM read failed\n");
2154                                 return IXGBE_ERR_EEPROM;
2155                         }
2156                         checksum += word;
2157                 }
2158         }
2159
2160         checksum = (u16)IXGBE_EEPROM_SUM - checksum;
2161
2162         return (s32)checksum;
2163 }
2164
2165 /**
2166  *  ixgbe_validate_eeprom_checksum_generic - Validate EEPROM checksum
2167  *  @hw: pointer to hardware structure
2168  *  @checksum_val: calculated checksum
2169  *
2170  *  Performs checksum calculation and validates the EEPROM checksum.  If the
2171  *  caller does not need checksum_val, the value can be NULL.
2172  **/
2173 s32 ixgbe_validate_eeprom_checksum_generic(struct ixgbe_hw *hw,
2174                                            u16 *checksum_val)
2175 {
2176         s32 status;
2177         u16 checksum;
2178         u16 read_checksum = 0;
2179
2180         DEBUGFUNC("ixgbe_validate_eeprom_checksum_generic");
2181
2182         /* Read the first word from the EEPROM. If this times out or fails, do
2183          * not continue or we could be in for a very long wait while every
2184          * EEPROM read fails
2185          */
2186         status = hw->eeprom.ops.read(hw, 0, &checksum);
2187         if (status) {
2188                 DEBUGOUT("EEPROM read failed\n");
2189                 return status;
2190         }
2191
2192         status = hw->eeprom.ops.calc_checksum(hw);
2193         if (status < 0)
2194                 return status;
2195
2196         checksum = (u16)(status & 0xffff);
2197
2198         status = hw->eeprom.ops.read(hw, IXGBE_EEPROM_CHECKSUM, &read_checksum);
2199         if (status) {
2200                 DEBUGOUT("EEPROM read failed\n");
2201                 return status;
2202         }
2203
2204         /* Verify read checksum from EEPROM is the same as
2205          * calculated checksum
2206          */
2207         if (read_checksum != checksum)
2208                 status = IXGBE_ERR_EEPROM_CHECKSUM;
2209
2210         /* If the user cares, return the calculated checksum */
2211         if (checksum_val)
2212                 *checksum_val = checksum;
2213
2214         return status;
2215 }
2216
2217 /**
2218  *  ixgbe_update_eeprom_checksum_generic - Updates the EEPROM checksum
2219  *  @hw: pointer to hardware structure
2220  **/
2221 s32 ixgbe_update_eeprom_checksum_generic(struct ixgbe_hw *hw)
2222 {
2223         s32 status;
2224         u16 checksum;
2225
2226         DEBUGFUNC("ixgbe_update_eeprom_checksum_generic");
2227
2228         /* Read the first word from the EEPROM. If this times out or fails, do
2229          * not continue or we could be in for a very long wait while every
2230          * EEPROM read fails
2231          */
2232         status = hw->eeprom.ops.read(hw, 0, &checksum);
2233         if (status) {
2234                 DEBUGOUT("EEPROM read failed\n");
2235                 return status;
2236         }
2237
2238         status = hw->eeprom.ops.calc_checksum(hw);
2239         if (status < 0)
2240                 return status;
2241
2242         checksum = (u16)(status & 0xffff);
2243
2244         status = hw->eeprom.ops.write(hw, IXGBE_EEPROM_CHECKSUM, checksum);
2245
2246         return status;
2247 }
2248
2249 /**
2250  *  ixgbe_validate_mac_addr - Validate MAC address
2251  *  @mac_addr: pointer to MAC address.
2252  *
2253  *  Tests a MAC address to ensure it is a valid Individual Address
2254  **/
2255 s32 ixgbe_validate_mac_addr(u8 *mac_addr)
2256 {
2257         s32 status = IXGBE_SUCCESS;
2258
2259         DEBUGFUNC("ixgbe_validate_mac_addr");
2260
2261         /* Make sure it is not a multicast address */
2262         if (IXGBE_IS_MULTICAST(mac_addr)) {
2263                 DEBUGOUT("MAC address is multicast\n");
2264                 status = IXGBE_ERR_INVALID_MAC_ADDR;
2265         /* Not a broadcast address */
2266         } else if (IXGBE_IS_BROADCAST(mac_addr)) {
2267                 DEBUGOUT("MAC address is broadcast\n");
2268                 status = IXGBE_ERR_INVALID_MAC_ADDR;
2269         /* Reject the zero address */
2270         } else if (mac_addr[0] == 0 && mac_addr[1] == 0 && mac_addr[2] == 0 &&
2271                    mac_addr[3] == 0 && mac_addr[4] == 0 && mac_addr[5] == 0) {
2272                 DEBUGOUT("MAC address is all zeros\n");
2273                 status = IXGBE_ERR_INVALID_MAC_ADDR;
2274         }
2275         return status;
2276 }
2277
2278 /**
2279  *  ixgbe_set_rar_generic - Set Rx address register
2280  *  @hw: pointer to hardware structure
2281  *  @index: Receive address register to write
2282  *  @addr: Address to put into receive address register
2283  *  @vmdq: VMDq "set" or "pool" index
2284  *  @enable_addr: set flag that address is active
2285  *
2286  *  Puts an ethernet address into a receive address register.
2287  **/
2288 s32 ixgbe_set_rar_generic(struct ixgbe_hw *hw, u32 index, u8 *addr, u32 vmdq,
2289                           u32 enable_addr)
2290 {
2291         u32 rar_low, rar_high;
2292         u32 rar_entries = hw->mac.num_rar_entries;
2293
2294         DEBUGFUNC("ixgbe_set_rar_generic");
2295
2296         /* Make sure we are using a valid rar index range */
2297         if (index >= rar_entries) {
2298                 ERROR_REPORT2(IXGBE_ERROR_ARGUMENT,
2299                              "RAR index %d is out of range.\n", index);
2300                 return IXGBE_ERR_INVALID_ARGUMENT;
2301         }
2302
2303         /* setup VMDq pool selection before this RAR gets enabled */
2304         hw->mac.ops.set_vmdq(hw, index, vmdq);
2305
2306         /*
2307          * HW expects these in little endian so we reverse the byte
2308          * order from network order (big endian) to little endian
2309          */
2310         rar_low = ((u32)addr[0] |
2311                    ((u32)addr[1] << 8) |
2312                    ((u32)addr[2] << 16) |
2313                    ((u32)addr[3] << 24));
2314         /*
2315          * Some parts put the VMDq setting in the extra RAH bits,
2316          * so save everything except the lower 16 bits that hold part
2317          * of the address and the address valid bit.
2318          */
2319         rar_high = IXGBE_READ_REG(hw, IXGBE_RAH(index));
2320         rar_high &= ~(0x0000FFFF | IXGBE_RAH_AV);
2321         rar_high |= ((u32)addr[4] | ((u32)addr[5] << 8));
2322
2323         if (enable_addr != 0)
2324                 rar_high |= IXGBE_RAH_AV;
2325
2326         IXGBE_WRITE_REG(hw, IXGBE_RAL(index), rar_low);
2327         IXGBE_WRITE_REG(hw, IXGBE_RAH(index), rar_high);
2328
2329         return IXGBE_SUCCESS;
2330 }
2331
2332 /**
2333  *  ixgbe_clear_rar_generic - Remove Rx address register
2334  *  @hw: pointer to hardware structure
2335  *  @index: Receive address register to write
2336  *
2337  *  Clears an ethernet address from a receive address register.
2338  **/
2339 s32 ixgbe_clear_rar_generic(struct ixgbe_hw *hw, u32 index)
2340 {
2341         u32 rar_high;
2342         u32 rar_entries = hw->mac.num_rar_entries;
2343
2344         DEBUGFUNC("ixgbe_clear_rar_generic");
2345
2346         /* Make sure we are using a valid rar index range */
2347         if (index >= rar_entries) {
2348                 ERROR_REPORT2(IXGBE_ERROR_ARGUMENT,
2349                              "RAR index %d is out of range.\n", index);
2350                 return IXGBE_ERR_INVALID_ARGUMENT;
2351         }
2352
2353         /*
2354          * Some parts put the VMDq setting in the extra RAH bits,
2355          * so save everything except the lower 16 bits that hold part
2356          * of the address and the address valid bit.
2357          */
2358         rar_high = IXGBE_READ_REG(hw, IXGBE_RAH(index));
2359         rar_high &= ~(0x0000FFFF | IXGBE_RAH_AV);
2360
2361         IXGBE_WRITE_REG(hw, IXGBE_RAL(index), 0);
2362         IXGBE_WRITE_REG(hw, IXGBE_RAH(index), rar_high);
2363
2364         /* clear VMDq pool/queue selection for this RAR */
2365         hw->mac.ops.clear_vmdq(hw, index, IXGBE_CLEAR_VMDQ_ALL);
2366
2367         return IXGBE_SUCCESS;
2368 }
2369
2370 /**
2371  *  ixgbe_init_rx_addrs_generic - Initializes receive address filters.
2372  *  @hw: pointer to hardware structure
2373  *
2374  *  Places the MAC address in receive address register 0 and clears the rest
2375  *  of the receive address registers. Clears the multicast table. Assumes
2376  *  the receiver is in reset when the routine is called.
2377  **/
2378 s32 ixgbe_init_rx_addrs_generic(struct ixgbe_hw *hw)
2379 {
2380         u32 i;
2381         u32 rar_entries = hw->mac.num_rar_entries;
2382
2383         DEBUGFUNC("ixgbe_init_rx_addrs_generic");
2384
2385         /*
2386          * If the current mac address is valid, assume it is a software override
2387          * to the permanent address.
2388          * Otherwise, use the permanent address from the eeprom.
2389          */
2390         if (ixgbe_validate_mac_addr(hw->mac.addr) ==
2391             IXGBE_ERR_INVALID_MAC_ADDR) {
2392                 /* Get the MAC address from the RAR0 for later reference */
2393                 hw->mac.ops.get_mac_addr(hw, hw->mac.addr);
2394
2395                 DEBUGOUT3(" Keeping Current RAR0 Addr =%.2X %.2X %.2X ",
2396                           hw->mac.addr[0], hw->mac.addr[1],
2397                           hw->mac.addr[2]);
2398                 DEBUGOUT3("%.2X %.2X %.2X\n", hw->mac.addr[3],
2399                           hw->mac.addr[4], hw->mac.addr[5]);
2400         } else {
2401                 /* Setup the receive address. */
2402                 DEBUGOUT("Overriding MAC Address in RAR[0]\n");
2403                 DEBUGOUT3(" New MAC Addr =%.2X %.2X %.2X ",
2404                           hw->mac.addr[0], hw->mac.addr[1],
2405                           hw->mac.addr[2]);
2406                 DEBUGOUT3("%.2X %.2X %.2X\n", hw->mac.addr[3],
2407                           hw->mac.addr[4], hw->mac.addr[5]);
2408
2409                 hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV);
2410
2411                 /* clear VMDq pool/queue selection for RAR 0 */
2412                 hw->mac.ops.clear_vmdq(hw, 0, IXGBE_CLEAR_VMDQ_ALL);
2413         }
2414         hw->addr_ctrl.overflow_promisc = 0;
2415
2416         hw->addr_ctrl.rar_used_count = 1;
2417
2418         /* Zero out the other receive addresses. */
2419         DEBUGOUT1("Clearing RAR[1-%d]\n", rar_entries - 1);
2420         for (i = 1; i < rar_entries; i++) {
2421                 IXGBE_WRITE_REG(hw, IXGBE_RAL(i), 0);
2422                 IXGBE_WRITE_REG(hw, IXGBE_RAH(i), 0);
2423         }
2424
2425         /* Clear the MTA */
2426         hw->addr_ctrl.mta_in_use = 0;
2427         IXGBE_WRITE_REG(hw, IXGBE_MCSTCTRL, hw->mac.mc_filter_type);
2428
2429         DEBUGOUT(" Clearing MTA\n");
2430         for (i = 0; i < hw->mac.mcft_size; i++)
2431                 IXGBE_WRITE_REG(hw, IXGBE_MTA(i), 0);
2432
2433         ixgbe_init_uta_tables(hw);
2434
2435         return IXGBE_SUCCESS;
2436 }
2437
2438 /**
2439  *  ixgbe_add_uc_addr - Adds a secondary unicast address.
2440  *  @hw: pointer to hardware structure
2441  *  @addr: new address
2442  *
2443  *  Adds it to unused receive address register or goes into promiscuous mode.
2444  **/
2445 void ixgbe_add_uc_addr(struct ixgbe_hw *hw, u8 *addr, u32 vmdq)
2446 {
2447         u32 rar_entries = hw->mac.num_rar_entries;
2448         u32 rar;
2449
2450         DEBUGFUNC("ixgbe_add_uc_addr");
2451
2452         DEBUGOUT6(" UC Addr = %.2X %.2X %.2X %.2X %.2X %.2X\n",
2453                   addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
2454
2455         /*
2456          * Place this address in the RAR if there is room,
2457          * else put the controller into promiscuous mode
2458          */
2459         if (hw->addr_ctrl.rar_used_count < rar_entries) {
2460                 rar = hw->addr_ctrl.rar_used_count;
2461                 hw->mac.ops.set_rar(hw, rar, addr, vmdq, IXGBE_RAH_AV);
2462                 DEBUGOUT1("Added a secondary address to RAR[%d]\n", rar);
2463                 hw->addr_ctrl.rar_used_count++;
2464         } else {
2465                 hw->addr_ctrl.overflow_promisc++;
2466         }
2467
2468         DEBUGOUT("ixgbe_add_uc_addr Complete\n");
2469 }
2470
2471 /**
2472  *  ixgbe_update_uc_addr_list_generic - Updates MAC list of secondary addresses
2473  *  @hw: pointer to hardware structure
2474  *  @addr_list: the list of new addresses
2475  *  @addr_count: number of addresses
2476  *  @next: iterator function to walk the address list
2477  *
2478  *  The given list replaces any existing list.  Clears the secondary addrs from
2479  *  receive address registers.  Uses unused receive address registers for the
2480  *  first secondary addresses, and falls back to promiscuous mode as needed.
2481  *
2482  *  Drivers using secondary unicast addresses must set user_set_promisc when
2483  *  manually putting the device into promiscuous mode.
2484  **/
2485 s32 ixgbe_update_uc_addr_list_generic(struct ixgbe_hw *hw, u8 *addr_list,
2486                                       u32 addr_count, ixgbe_mc_addr_itr next)
2487 {
2488         u8 *addr;
2489         u32 i;
2490         u32 old_promisc_setting = hw->addr_ctrl.overflow_promisc;
2491         u32 uc_addr_in_use;
2492         u32 fctrl;
2493         u32 vmdq;
2494
2495         DEBUGFUNC("ixgbe_update_uc_addr_list_generic");
2496
2497         /*
2498          * Clear accounting of old secondary address list,
2499          * don't count RAR[0]
2500          */
2501         uc_addr_in_use = hw->addr_ctrl.rar_used_count - 1;
2502         hw->addr_ctrl.rar_used_count -= uc_addr_in_use;
2503         hw->addr_ctrl.overflow_promisc = 0;
2504
2505         /* Zero out the other receive addresses */
2506         DEBUGOUT1("Clearing RAR[1-%d]\n", uc_addr_in_use+1);
2507         for (i = 0; i < uc_addr_in_use; i++) {
2508                 IXGBE_WRITE_REG(hw, IXGBE_RAL(1+i), 0);
2509                 IXGBE_WRITE_REG(hw, IXGBE_RAH(1+i), 0);
2510         }
2511
2512         /* Add the new addresses */
2513         for (i = 0; i < addr_count; i++) {
2514                 DEBUGOUT(" Adding the secondary addresses:\n");
2515                 addr = next(hw, &addr_list, &vmdq);
2516                 ixgbe_add_uc_addr(hw, addr, vmdq);
2517         }
2518
2519         if (hw->addr_ctrl.overflow_promisc) {
2520                 /* enable promisc if not already in overflow or set by user */
2521                 if (!old_promisc_setting && !hw->addr_ctrl.user_set_promisc) {
2522                         DEBUGOUT(" Entering address overflow promisc mode\n");
2523                         fctrl = IXGBE_READ_REG(hw, IXGBE_FCTRL);
2524                         fctrl |= IXGBE_FCTRL_UPE;
2525                         IXGBE_WRITE_REG(hw, IXGBE_FCTRL, fctrl);
2526                 }
2527         } else {
2528                 /* only disable if set by overflow, not by user */
2529                 if (old_promisc_setting && !hw->addr_ctrl.user_set_promisc) {
2530                         DEBUGOUT(" Leaving address overflow promisc mode\n");
2531                         fctrl = IXGBE_READ_REG(hw, IXGBE_FCTRL);
2532                         fctrl &= ~IXGBE_FCTRL_UPE;
2533                         IXGBE_WRITE_REG(hw, IXGBE_FCTRL, fctrl);
2534                 }
2535         }
2536
2537         DEBUGOUT("ixgbe_update_uc_addr_list_generic Complete\n");
2538         return IXGBE_SUCCESS;
2539 }
2540
2541 /**
2542  *  ixgbe_mta_vector - Determines bit-vector in multicast table to set
2543  *  @hw: pointer to hardware structure
2544  *  @mc_addr: the multicast address
2545  *
2546  *  Extracts the 12 bits, from a multicast address, to determine which
2547  *  bit-vector to set in the multicast table. The hardware uses 12 bits, from
2548  *  incoming rx multicast addresses, to determine the bit-vector to check in
2549  *  the MTA. Which of the 4 combination, of 12-bits, the hardware uses is set
2550  *  by the MO field of the MCSTCTRL. The MO field is set during initialization
2551  *  to mc_filter_type.
2552  **/
2553 static s32 ixgbe_mta_vector(struct ixgbe_hw *hw, u8 *mc_addr)
2554 {
2555         u32 vector = 0;
2556
2557         DEBUGFUNC("ixgbe_mta_vector");
2558
2559         switch (hw->mac.mc_filter_type) {
2560         case 0:   /* use bits [47:36] of the address */
2561                 vector = ((mc_addr[4] >> 4) | (((u16)mc_addr[5]) << 4));
2562                 break;
2563         case 1:   /* use bits [46:35] of the address */
2564                 vector = ((mc_addr[4] >> 3) | (((u16)mc_addr[5]) << 5));
2565                 break;
2566         case 2:   /* use bits [45:34] of the address */
2567                 vector = ((mc_addr[4] >> 2) | (((u16)mc_addr[5]) << 6));
2568                 break;
2569         case 3:   /* use bits [43:32] of the address */
2570                 vector = ((mc_addr[4]) | (((u16)mc_addr[5]) << 8));
2571                 break;
2572         default:  /* Invalid mc_filter_type */
2573                 DEBUGOUT("MC filter type param set incorrectly\n");
2574                 ASSERT(0);
2575                 break;
2576         }
2577
2578         /* vector can only be 12-bits or boundary will be exceeded */
2579         vector &= 0xFFF;
2580         return vector;
2581 }
2582
2583 /**
2584  *  ixgbe_set_mta - Set bit-vector in multicast table
2585  *  @hw: pointer to hardware structure
2586  *  @hash_value: Multicast address hash value
2587  *
2588  *  Sets the bit-vector in the multicast table.
2589  **/
2590 void ixgbe_set_mta(struct ixgbe_hw *hw, u8 *mc_addr)
2591 {
2592         u32 vector;
2593         u32 vector_bit;
2594         u32 vector_reg;
2595
2596         DEBUGFUNC("ixgbe_set_mta");
2597
2598         hw->addr_ctrl.mta_in_use++;
2599
2600         vector = ixgbe_mta_vector(hw, mc_addr);
2601         DEBUGOUT1(" bit-vector = 0x%03X\n", vector);
2602
2603         /*
2604          * The MTA is a register array of 128 32-bit registers. It is treated
2605          * like an array of 4096 bits.  We want to set bit
2606          * BitArray[vector_value]. So we figure out what register the bit is
2607          * in, read it, OR in the new bit, then write back the new value.  The
2608          * register is determined by the upper 7 bits of the vector value and
2609          * the bit within that register are determined by the lower 5 bits of
2610          * the value.
2611          */
2612         vector_reg = (vector >> 5) & 0x7F;
2613         vector_bit = vector & 0x1F;
2614         hw->mac.mta_shadow[vector_reg] |= (1 << vector_bit);
2615 }
2616
2617 /**
2618  *  ixgbe_update_mc_addr_list_generic - Updates MAC list of multicast addresses
2619  *  @hw: pointer to hardware structure
2620  *  @mc_addr_list: the list of new multicast addresses
2621  *  @mc_addr_count: number of addresses
2622  *  @next: iterator function to walk the multicast address list
2623  *  @clear: flag, when set clears the table beforehand
2624  *
2625  *  When the clear flag is set, the given list replaces any existing list.
2626  *  Hashes the given addresses into the multicast table.
2627  **/
2628 s32 ixgbe_update_mc_addr_list_generic(struct ixgbe_hw *hw, u8 *mc_addr_list,
2629                                       u32 mc_addr_count, ixgbe_mc_addr_itr next,
2630                                       bool clear)
2631 {
2632         u32 i;
2633         u32 vmdq;
2634
2635         DEBUGFUNC("ixgbe_update_mc_addr_list_generic");
2636
2637         /*
2638          * Set the new number of MC addresses that we are being requested to
2639          * use.
2640          */
2641         hw->addr_ctrl.num_mc_addrs = mc_addr_count;
2642         hw->addr_ctrl.mta_in_use = 0;
2643
2644         /* Clear mta_shadow */
2645         if (clear) {
2646                 DEBUGOUT(" Clearing MTA\n");
2647                 memset(&hw->mac.mta_shadow, 0, sizeof(hw->mac.mta_shadow));
2648         }
2649
2650         /* Update mta_shadow */
2651         for (i = 0; i < mc_addr_count; i++) {
2652                 DEBUGOUT(" Adding the multicast addresses:\n");
2653                 ixgbe_set_mta(hw, next(hw, &mc_addr_list, &vmdq));
2654         }
2655
2656         /* Enable mta */
2657         for (i = 0; i < hw->mac.mcft_size; i++)
2658                 IXGBE_WRITE_REG_ARRAY(hw, IXGBE_MTA(0), i,
2659                                       hw->mac.mta_shadow[i]);
2660
2661         if (hw->addr_ctrl.mta_in_use > 0)
2662                 IXGBE_WRITE_REG(hw, IXGBE_MCSTCTRL,
2663                                 IXGBE_MCSTCTRL_MFE | hw->mac.mc_filter_type);
2664
2665         DEBUGOUT("ixgbe_update_mc_addr_list_generic Complete\n");
2666         return IXGBE_SUCCESS;
2667 }
2668
2669 /**
2670  *  ixgbe_enable_mc_generic - Enable multicast address in RAR
2671  *  @hw: pointer to hardware structure
2672  *
2673  *  Enables multicast address in RAR and the use of the multicast hash table.
2674  **/
2675 s32 ixgbe_enable_mc_generic(struct ixgbe_hw *hw)
2676 {
2677         struct ixgbe_addr_filter_info *a = &hw->addr_ctrl;
2678
2679         DEBUGFUNC("ixgbe_enable_mc_generic");
2680
2681         if (a->mta_in_use > 0)
2682                 IXGBE_WRITE_REG(hw, IXGBE_MCSTCTRL, IXGBE_MCSTCTRL_MFE |
2683                                 hw->mac.mc_filter_type);
2684
2685         return IXGBE_SUCCESS;
2686 }
2687
2688 /**
2689  *  ixgbe_disable_mc_generic - Disable multicast address in RAR
2690  *  @hw: pointer to hardware structure
2691  *
2692  *  Disables multicast address in RAR and the use of the multicast hash table.
2693  **/
2694 s32 ixgbe_disable_mc_generic(struct ixgbe_hw *hw)
2695 {
2696         struct ixgbe_addr_filter_info *a = &hw->addr_ctrl;
2697
2698         DEBUGFUNC("ixgbe_disable_mc_generic");
2699
2700         if (a->mta_in_use > 0)
2701                 IXGBE_WRITE_REG(hw, IXGBE_MCSTCTRL, hw->mac.mc_filter_type);
2702
2703         return IXGBE_SUCCESS;
2704 }
2705
2706 /**
2707  *  ixgbe_fc_enable_generic - Enable flow control
2708  *  @hw: pointer to hardware structure
2709  *
2710  *  Enable flow control according to the current settings.
2711  **/
2712 s32 ixgbe_fc_enable_generic(struct ixgbe_hw *hw)
2713 {
2714         s32 ret_val = IXGBE_SUCCESS;
2715         u32 mflcn_reg, fccfg_reg;
2716         u32 reg;
2717         u32 fcrtl, fcrth;
2718         int i;
2719
2720         DEBUGFUNC("ixgbe_fc_enable_generic");
2721
2722         /* Validate the water mark configuration */
2723         if (!hw->fc.pause_time) {
2724                 ret_val = IXGBE_ERR_INVALID_LINK_SETTINGS;
2725                 goto out;
2726         }
2727
2728         /* Low water mark of zero causes XOFF floods */
2729         for (i = 0; i < IXGBE_DCB_MAX_TRAFFIC_CLASS; i++) {
2730                 if ((hw->fc.current_mode & ixgbe_fc_tx_pause) &&
2731                     hw->fc.high_water[i]) {
2732                         if (!hw->fc.low_water[i] ||
2733                             hw->fc.low_water[i] >= hw->fc.high_water[i]) {
2734                                 DEBUGOUT("Invalid water mark configuration\n");
2735                                 ret_val = IXGBE_ERR_INVALID_LINK_SETTINGS;
2736                                 goto out;
2737                         }
2738                 }
2739         }
2740
2741         /* Negotiate the fc mode to use */
2742         ixgbe_fc_autoneg(hw);
2743
2744         /* Disable any previous flow control settings */
2745         mflcn_reg = IXGBE_READ_REG(hw, IXGBE_MFLCN);
2746         mflcn_reg &= ~(IXGBE_MFLCN_RPFCE_MASK | IXGBE_MFLCN_RFCE);
2747
2748         fccfg_reg = IXGBE_READ_REG(hw, IXGBE_FCCFG);
2749         fccfg_reg &= ~(IXGBE_FCCFG_TFCE_802_3X | IXGBE_FCCFG_TFCE_PRIORITY);
2750
2751         /*
2752          * The possible values of fc.current_mode are:
2753          * 0: Flow control is completely disabled
2754          * 1: Rx flow control is enabled (we can receive pause frames,
2755          *    but not send pause frames).
2756          * 2: Tx flow control is enabled (we can send pause frames but
2757          *    we do not support receiving pause frames).
2758          * 3: Both Rx and Tx flow control (symmetric) are enabled.
2759          * other: Invalid.
2760          */
2761         switch (hw->fc.current_mode) {
2762         case ixgbe_fc_none:
2763                 /*
2764                  * Flow control is disabled by software override or autoneg.
2765                  * The code below will actually disable it in the HW.
2766                  */
2767                 break;
2768         case ixgbe_fc_rx_pause:
2769                 /*
2770                  * Rx Flow control is enabled and Tx Flow control is
2771                  * disabled by software override. Since there really
2772                  * isn't a way to advertise that we are capable of RX
2773                  * Pause ONLY, we will advertise that we support both
2774                  * symmetric and asymmetric Rx PAUSE.  Later, we will
2775                  * disable the adapter's ability to send PAUSE frames.
2776                  */
2777                 mflcn_reg |= IXGBE_MFLCN_RFCE;
2778                 break;
2779         case ixgbe_fc_tx_pause:
2780                 /*
2781                  * Tx Flow control is enabled, and Rx Flow control is
2782                  * disabled by software override.
2783                  */
2784                 fccfg_reg |= IXGBE_FCCFG_TFCE_802_3X;
2785                 break;
2786         case ixgbe_fc_full:
2787                 /* Flow control (both Rx and Tx) is enabled by SW override. */
2788                 mflcn_reg |= IXGBE_MFLCN_RFCE;
2789                 fccfg_reg |= IXGBE_FCCFG_TFCE_802_3X;
2790                 break;
2791         default:
2792                 ERROR_REPORT1(IXGBE_ERROR_ARGUMENT,
2793                              "Flow control param set incorrectly\n");
2794                 ret_val = IXGBE_ERR_CONFIG;
2795                 goto out;
2796                 break;
2797         }
2798
2799         /* Set 802.3x based flow control settings. */
2800         mflcn_reg |= IXGBE_MFLCN_DPF;
2801         IXGBE_WRITE_REG(hw, IXGBE_MFLCN, mflcn_reg);
2802         IXGBE_WRITE_REG(hw, IXGBE_FCCFG, fccfg_reg);
2803
2804
2805         /* Set up and enable Rx high/low water mark thresholds, enable XON. */
2806         for (i = 0; i < IXGBE_DCB_MAX_TRAFFIC_CLASS; i++) {
2807                 if ((hw->fc.current_mode & ixgbe_fc_tx_pause) &&
2808                     hw->fc.high_water[i]) {
2809                         fcrtl = (hw->fc.low_water[i] << 10) | IXGBE_FCRTL_XONE;
2810                         IXGBE_WRITE_REG(hw, IXGBE_FCRTL_82599(i), fcrtl);
2811                         fcrth = (hw->fc.high_water[i] << 10) | IXGBE_FCRTH_FCEN;
2812                 } else {
2813                         IXGBE_WRITE_REG(hw, IXGBE_FCRTL_82599(i), 0);
2814                         /*
2815                          * In order to prevent Tx hangs when the internal Tx
2816                          * switch is enabled we must set the high water mark
2817                          * to the Rx packet buffer size - 24KB.  This allows
2818                          * the Tx switch to function even under heavy Rx
2819                          * workloads.
2820                          */
2821                         fcrth = IXGBE_READ_REG(hw, IXGBE_RXPBSIZE(i)) - 24576;
2822                 }
2823
2824                 IXGBE_WRITE_REG(hw, IXGBE_FCRTH_82599(i), fcrth);
2825         }
2826
2827         /* Configure pause time (2 TCs per register) */
2828         reg = hw->fc.pause_time * 0x00010001;
2829         for (i = 0; i < (IXGBE_DCB_MAX_TRAFFIC_CLASS / 2); i++)
2830                 IXGBE_WRITE_REG(hw, IXGBE_FCTTV(i), reg);
2831
2832         /* Configure flow control refresh threshold value */
2833         IXGBE_WRITE_REG(hw, IXGBE_FCRTV, hw->fc.pause_time / 2);
2834
2835 out:
2836         return ret_val;
2837 }
2838
2839 /**
2840  *  ixgbe_negotiate_fc - Negotiate flow control
2841  *  @hw: pointer to hardware structure
2842  *  @adv_reg: flow control advertised settings
2843  *  @lp_reg: link partner's flow control settings
2844  *  @adv_sym: symmetric pause bit in advertisement
2845  *  @adv_asm: asymmetric pause bit in advertisement
2846  *  @lp_sym: symmetric pause bit in link partner advertisement
2847  *  @lp_asm: asymmetric pause bit in link partner advertisement
2848  *
2849  *  Find the intersection between advertised settings and link partner's
2850  *  advertised settings
2851  **/
2852 static s32 ixgbe_negotiate_fc(struct ixgbe_hw *hw, u32 adv_reg, u32 lp_reg,
2853                               u32 adv_sym, u32 adv_asm, u32 lp_sym, u32 lp_asm)
2854 {
2855         if ((!(adv_reg)) ||  (!(lp_reg))) {
2856                 ERROR_REPORT3(IXGBE_ERROR_UNSUPPORTED,
2857                              "Local or link partner's advertised flow control "
2858                              "settings are NULL. Local: %x, link partner: %x\n",
2859                              adv_reg, lp_reg);
2860                 return IXGBE_ERR_FC_NOT_NEGOTIATED;
2861         }
2862
2863         if ((adv_reg & adv_sym) && (lp_reg & lp_sym)) {
2864                 /*
2865                  * Now we need to check if the user selected Rx ONLY
2866                  * of pause frames.  In this case, we had to advertise
2867                  * FULL flow control because we could not advertise RX
2868                  * ONLY. Hence, we must now check to see if we need to
2869                  * turn OFF the TRANSMISSION of PAUSE frames.
2870                  */
2871                 if (hw->fc.requested_mode == ixgbe_fc_full) {
2872                         hw->fc.current_mode = ixgbe_fc_full;
2873                         DEBUGOUT("Flow Control = FULL.\n");
2874                 } else {
2875                         hw->fc.current_mode = ixgbe_fc_rx_pause;
2876                         DEBUGOUT("Flow Control=RX PAUSE frames only\n");
2877                 }
2878         } else if (!(adv_reg & adv_sym) && (adv_reg & adv_asm) &&
2879                    (lp_reg & lp_sym) && (lp_reg & lp_asm)) {
2880                 hw->fc.current_mode = ixgbe_fc_tx_pause;
2881                 DEBUGOUT("Flow Control = TX PAUSE frames only.\n");
2882         } else if ((adv_reg & adv_sym) && (adv_reg & adv_asm) &&
2883                    !(lp_reg & lp_sym) && (lp_reg & lp_asm)) {
2884                 hw->fc.current_mode = ixgbe_fc_rx_pause;
2885                 DEBUGOUT("Flow Control = RX PAUSE frames only.\n");
2886         } else {
2887                 hw->fc.current_mode = ixgbe_fc_none;
2888                 DEBUGOUT("Flow Control = NONE.\n");
2889         }
2890         return IXGBE_SUCCESS;
2891 }
2892
2893 /**
2894  *  ixgbe_fc_autoneg_fiber - Enable flow control on 1 gig fiber
2895  *  @hw: pointer to hardware structure
2896  *
2897  *  Enable flow control according on 1 gig fiber.
2898  **/
2899 static s32 ixgbe_fc_autoneg_fiber(struct ixgbe_hw *hw)
2900 {
2901         u32 pcs_anadv_reg, pcs_lpab_reg, linkstat;
2902         s32 ret_val = IXGBE_ERR_FC_NOT_NEGOTIATED;
2903
2904         /*
2905          * On multispeed fiber at 1g, bail out if
2906          * - link is up but AN did not complete, or if
2907          * - link is up and AN completed but timed out
2908          */
2909
2910         linkstat = IXGBE_READ_REG(hw, IXGBE_PCS1GLSTA);
2911         if ((!!(linkstat & IXGBE_PCS1GLSTA_AN_COMPLETE) == 0) ||
2912             (!!(linkstat & IXGBE_PCS1GLSTA_AN_TIMED_OUT) == 1)) {
2913                 DEBUGOUT("Auto-Negotiation did not complete or timed out\n");
2914                 goto out;
2915         }
2916
2917         pcs_anadv_reg = IXGBE_READ_REG(hw, IXGBE_PCS1GANA);
2918         pcs_lpab_reg = IXGBE_READ_REG(hw, IXGBE_PCS1GANLP);
2919
2920         ret_val =  ixgbe_negotiate_fc(hw, pcs_anadv_reg,
2921                                       pcs_lpab_reg, IXGBE_PCS1GANA_SYM_PAUSE,
2922                                       IXGBE_PCS1GANA_ASM_PAUSE,
2923                                       IXGBE_PCS1GANA_SYM_PAUSE,
2924                                       IXGBE_PCS1GANA_ASM_PAUSE);
2925
2926 out:
2927         return ret_val;
2928 }
2929
2930 /**
2931  *  ixgbe_fc_autoneg_backplane - Enable flow control IEEE clause 37
2932  *  @hw: pointer to hardware structure
2933  *
2934  *  Enable flow control according to IEEE clause 37.
2935  **/
2936 static s32 ixgbe_fc_autoneg_backplane(struct ixgbe_hw *hw)
2937 {
2938         u32 links2, anlp1_reg, autoc_reg, links;
2939         s32 ret_val = IXGBE_ERR_FC_NOT_NEGOTIATED;
2940
2941         /*
2942          * On backplane, bail out if
2943          * - backplane autoneg was not completed, or if
2944          * - we are 82599 and link partner is not AN enabled
2945          */
2946         links = IXGBE_READ_REG(hw, IXGBE_LINKS);
2947         if ((links & IXGBE_LINKS_KX_AN_COMP) == 0) {
2948                 DEBUGOUT("Auto-Negotiation did not complete\n");
2949                 goto out;
2950         }
2951
2952         if (hw->mac.type == ixgbe_mac_82599EB) {
2953                 links2 = IXGBE_READ_REG(hw, IXGBE_LINKS2);
2954                 if ((links2 & IXGBE_LINKS2_AN_SUPPORTED) == 0) {
2955                         DEBUGOUT("Link partner is not AN enabled\n");
2956                         goto out;
2957                 }
2958         }
2959         /*
2960          * Read the 10g AN autoc and LP ability registers and resolve
2961          * local flow control settings accordingly
2962          */
2963         autoc_reg = IXGBE_READ_REG(hw, IXGBE_AUTOC);
2964         anlp1_reg = IXGBE_READ_REG(hw, IXGBE_ANLP1);
2965
2966         ret_val = ixgbe_negotiate_fc(hw, autoc_reg,
2967                 anlp1_reg, IXGBE_AUTOC_SYM_PAUSE, IXGBE_AUTOC_ASM_PAUSE,
2968                 IXGBE_ANLP1_SYM_PAUSE, IXGBE_ANLP1_ASM_PAUSE);
2969
2970 out:
2971         return ret_val;
2972 }
2973
2974 /**
2975  *  ixgbe_fc_autoneg_copper - Enable flow control IEEE clause 37
2976  *  @hw: pointer to hardware structure
2977  *
2978  *  Enable flow control according to IEEE clause 37.
2979  **/
2980 static s32 ixgbe_fc_autoneg_copper(struct ixgbe_hw *hw)
2981 {
2982         u16 technology_ability_reg = 0;
2983         u16 lp_technology_ability_reg = 0;
2984
2985         hw->phy.ops.read_reg(hw, IXGBE_MDIO_AUTO_NEG_ADVT,
2986                              IXGBE_MDIO_AUTO_NEG_DEV_TYPE,
2987                              &technology_ability_reg);
2988         hw->phy.ops.read_reg(hw, IXGBE_MDIO_AUTO_NEG_LP,
2989                              IXGBE_MDIO_AUTO_NEG_DEV_TYPE,
2990                              &lp_technology_ability_reg);
2991
2992         return ixgbe_negotiate_fc(hw, (u32)technology_ability_reg,
2993                                   (u32)lp_technology_ability_reg,
2994                                   IXGBE_TAF_SYM_PAUSE, IXGBE_TAF_ASM_PAUSE,
2995                                   IXGBE_TAF_SYM_PAUSE, IXGBE_TAF_ASM_PAUSE);
2996 }
2997
2998 /**
2999  *  ixgbe_fc_autoneg - Configure flow control
3000  *  @hw: pointer to hardware structure
3001  *
3002  *  Compares our advertised flow control capabilities to those advertised by
3003  *  our link partner, and determines the proper flow control mode to use.
3004  **/
3005 void ixgbe_fc_autoneg(struct ixgbe_hw *hw)
3006 {
3007         s32 ret_val = IXGBE_ERR_FC_NOT_NEGOTIATED;
3008         ixgbe_link_speed speed;
3009         bool link_up;
3010
3011         DEBUGFUNC("ixgbe_fc_autoneg");
3012
3013         /*
3014          * AN should have completed when the cable was plugged in.
3015          * Look for reasons to bail out.  Bail out if:
3016          * - FC autoneg is disabled, or if
3017          * - link is not up.
3018          */
3019         if (hw->fc.disable_fc_autoneg) {
3020                 ERROR_REPORT1(IXGBE_ERROR_UNSUPPORTED,
3021                              "Flow control autoneg is disabled");
3022                 goto out;
3023         }
3024
3025         hw->mac.ops.check_link(hw, &speed, &link_up, FALSE);
3026         if (!link_up) {
3027                 ERROR_REPORT1(IXGBE_ERROR_SOFTWARE, "The link is down");
3028                 goto out;
3029         }
3030
3031         switch (hw->phy.media_type) {
3032         /* Autoneg flow control on fiber adapters */
3033         case ixgbe_media_type_fiber_fixed:
3034         case ixgbe_media_type_fiber_qsfp:
3035         case ixgbe_media_type_fiber:
3036                 if (speed == IXGBE_LINK_SPEED_1GB_FULL)
3037                         ret_val = ixgbe_fc_autoneg_fiber(hw);
3038                 break;
3039
3040         /* Autoneg flow control on backplane adapters */
3041         case ixgbe_media_type_backplane:
3042                 ret_val = ixgbe_fc_autoneg_backplane(hw);
3043                 break;
3044
3045         /* Autoneg flow control on copper adapters */
3046         case ixgbe_media_type_copper:
3047                 if (ixgbe_device_supports_autoneg_fc(hw))
3048                         ret_val = ixgbe_fc_autoneg_copper(hw);
3049                 break;
3050
3051         default:
3052                 break;
3053         }
3054
3055 out:
3056         if (ret_val == IXGBE_SUCCESS) {
3057                 hw->fc.fc_was_autonegged = TRUE;
3058         } else {
3059                 hw->fc.fc_was_autonegged = FALSE;
3060                 hw->fc.current_mode = hw->fc.requested_mode;
3061         }
3062 }
3063
3064 /*
3065  * ixgbe_pcie_timeout_poll - Return number of times to poll for completion
3066  * @hw: pointer to hardware structure
3067  *
3068  * System-wide timeout range is encoded in PCIe Device Control2 register.
3069  *
3070  * Add 10% to specified maximum and return the number of times to poll for
3071  * completion timeout, in units of 100 microsec.  Never return less than
3072  * 800 = 80 millisec.
3073  */
3074 static u32 ixgbe_pcie_timeout_poll(struct ixgbe_hw *hw)
3075 {
3076         s16 devctl2;
3077         u32 pollcnt;
3078
3079         devctl2 = IXGBE_READ_PCIE_WORD(hw, IXGBE_PCI_DEVICE_CONTROL2);
3080         devctl2 &= IXGBE_PCIDEVCTRL2_TIMEO_MASK;
3081
3082         switch (devctl2) {
3083         case IXGBE_PCIDEVCTRL2_65_130ms:
3084                 pollcnt = 1300;         /* 130 millisec */
3085                 break;
3086         case IXGBE_PCIDEVCTRL2_260_520ms:
3087                 pollcnt = 5200;         /* 520 millisec */
3088                 break;
3089         case IXGBE_PCIDEVCTRL2_1_2s:
3090                 pollcnt = 20000;        /* 2 sec */
3091                 break;
3092         case IXGBE_PCIDEVCTRL2_4_8s:
3093                 pollcnt = 80000;        /* 8 sec */
3094                 break;
3095         case IXGBE_PCIDEVCTRL2_17_34s:
3096                 pollcnt = 34000;        /* 34 sec */
3097                 break;
3098         case IXGBE_PCIDEVCTRL2_50_100us:        /* 100 microsecs */
3099         case IXGBE_PCIDEVCTRL2_1_2ms:           /* 2 millisecs */
3100         case IXGBE_PCIDEVCTRL2_16_32ms:         /* 32 millisec */
3101         case IXGBE_PCIDEVCTRL2_16_32ms_def:     /* 32 millisec default */
3102         default:
3103                 pollcnt = 800;          /* 80 millisec minimum */
3104                 break;
3105         }
3106
3107         /* add 10% to spec maximum */
3108         return (pollcnt * 11) / 10;
3109 }
3110
3111 /**
3112  *  ixgbe_disable_pcie_master - Disable PCI-express master access
3113  *  @hw: pointer to hardware structure
3114  *
3115  *  Disables PCI-Express master access and verifies there are no pending
3116  *  requests. IXGBE_ERR_MASTER_REQUESTS_PENDING is returned if master disable
3117  *  bit hasn't caused the master requests to be disabled, else IXGBE_SUCCESS
3118  *  is returned signifying master requests disabled.
3119  **/
3120 s32 ixgbe_disable_pcie_master(struct ixgbe_hw *hw)
3121 {
3122         s32 status = IXGBE_SUCCESS;
3123         u32 i, poll;
3124         u16 value;
3125
3126         DEBUGFUNC("ixgbe_disable_pcie_master");
3127
3128         /* Always set this bit to ensure any future transactions are blocked */
3129         IXGBE_WRITE_REG(hw, IXGBE_CTRL, IXGBE_CTRL_GIO_DIS);
3130
3131         /* Exit if master requests are blocked */
3132         if (!(IXGBE_READ_REG(hw, IXGBE_STATUS) & IXGBE_STATUS_GIO) ||
3133             IXGBE_REMOVED(hw->hw_addr))
3134                 goto out;
3135
3136         /* Poll for master request bit to clear */
3137         for (i = 0; i < IXGBE_PCI_MASTER_DISABLE_TIMEOUT; i++) {
3138                 usec_delay(100);
3139                 if (!(IXGBE_READ_REG(hw, IXGBE_STATUS) & IXGBE_STATUS_GIO))
3140                         goto out;
3141         }
3142
3143         /*
3144          * Two consecutive resets are required via CTRL.RST per datasheet
3145          * 5.2.5.3.2 Master Disable.  We set a flag to inform the reset routine
3146          * of this need.  The first reset prevents new master requests from
3147          * being issued by our device.  We then must wait 1usec or more for any
3148          * remaining completions from the PCIe bus to trickle in, and then reset
3149          * again to clear out any effects they may have had on our device.
3150          */
3151         DEBUGOUT("GIO Master Disable bit didn't clear - requesting resets\n");
3152         hw->mac.flags |= IXGBE_FLAGS_DOUBLE_RESET_REQUIRED;
3153
3154         if (hw->mac.type >= ixgbe_mac_X550)
3155                 goto out;
3156
3157         /*
3158          * Before proceeding, make sure that the PCIe block does not have
3159          * transactions pending.
3160          */
3161         poll = ixgbe_pcie_timeout_poll(hw);
3162         for (i = 0; i < poll; i++) {
3163                 usec_delay(100);
3164                 value = IXGBE_READ_PCIE_WORD(hw, IXGBE_PCI_DEVICE_STATUS);
3165                 if (IXGBE_REMOVED(hw->hw_addr))
3166                         goto out;
3167                 if (!(value & IXGBE_PCI_DEVICE_STATUS_TRANSACTION_PENDING))
3168                         goto out;
3169         }
3170
3171         ERROR_REPORT1(IXGBE_ERROR_POLLING,
3172                      "PCIe transaction pending bit also did not clear.\n");
3173         status = IXGBE_ERR_MASTER_REQUESTS_PENDING;
3174
3175 out:
3176         return status;
3177 }
3178
3179 /**
3180  *  ixgbe_acquire_swfw_sync - Acquire SWFW semaphore
3181  *  @hw: pointer to hardware structure
3182  *  @mask: Mask to specify which semaphore to acquire
3183  *
3184  *  Acquires the SWFW semaphore through the GSSR register for the specified
3185  *  function (CSR, PHY0, PHY1, EEPROM, Flash)
3186  **/
3187 s32 ixgbe_acquire_swfw_sync(struct ixgbe_hw *hw, u32 mask)
3188 {
3189         u32 gssr = 0;
3190         u32 swmask = mask;
3191         u32 fwmask = mask << 5;
3192         u32 timeout = 200;
3193         u32 i;
3194
3195         DEBUGFUNC("ixgbe_acquire_swfw_sync");
3196
3197         for (i = 0; i < timeout; i++) {
3198                 /*
3199                  * SW NVM semaphore bit is used for access to all
3200                  * SW_FW_SYNC bits (not just NVM)
3201                  */
3202                 if (ixgbe_get_eeprom_semaphore(hw))
3203                         return IXGBE_ERR_SWFW_SYNC;
3204
3205                 gssr = IXGBE_READ_REG(hw, IXGBE_GSSR);
3206                 if (!(gssr & (fwmask | swmask))) {
3207                         gssr |= swmask;
3208                         IXGBE_WRITE_REG(hw, IXGBE_GSSR, gssr);
3209                         ixgbe_release_eeprom_semaphore(hw);
3210                         return IXGBE_SUCCESS;
3211                 } else {
3212                         /* Resource is currently in use by FW or SW */
3213                         ixgbe_release_eeprom_semaphore(hw);
3214                         msec_delay(5);
3215                 }
3216         }
3217
3218         /* If time expired clear the bits holding the lock and retry */
3219         if (gssr & (fwmask | swmask))
3220                 ixgbe_release_swfw_sync(hw, gssr & (fwmask | swmask));
3221
3222         msec_delay(5);
3223         return IXGBE_ERR_SWFW_SYNC;
3224 }
3225
3226 /**
3227  *  ixgbe_release_swfw_sync - Release SWFW semaphore
3228  *  @hw: pointer to hardware structure
3229  *  @mask: Mask to specify which semaphore to release
3230  *
3231  *  Releases the SWFW semaphore through the GSSR register for the specified
3232  *  function (CSR, PHY0, PHY1, EEPROM, Flash)
3233  **/
3234 void ixgbe_release_swfw_sync(struct ixgbe_hw *hw, u32 mask)
3235 {
3236         u32 gssr;
3237         u32 swmask = mask;
3238
3239         DEBUGFUNC("ixgbe_release_swfw_sync");
3240
3241         ixgbe_get_eeprom_semaphore(hw);
3242
3243         gssr = IXGBE_READ_REG(hw, IXGBE_GSSR);
3244         gssr &= ~swmask;
3245         IXGBE_WRITE_REG(hw, IXGBE_GSSR, gssr);
3246
3247         ixgbe_release_eeprom_semaphore(hw);
3248 }
3249
3250 /**
3251  *  ixgbe_disable_sec_rx_path_generic - Stops the receive data path
3252  *  @hw: pointer to hardware structure
3253  *
3254  *  Stops the receive data path and waits for the HW to internally empty
3255  *  the Rx security block
3256  **/
3257 s32 ixgbe_disable_sec_rx_path_generic(struct ixgbe_hw *hw)
3258 {
3259 #define IXGBE_MAX_SECRX_POLL 40
3260
3261         int i;
3262         int secrxreg;
3263
3264         DEBUGFUNC("ixgbe_disable_sec_rx_path_generic");
3265
3266
3267         secrxreg = IXGBE_READ_REG(hw, IXGBE_SECRXCTRL);
3268         secrxreg |= IXGBE_SECRXCTRL_RX_DIS;
3269         IXGBE_WRITE_REG(hw, IXGBE_SECRXCTRL, secrxreg);
3270         for (i = 0; i < IXGBE_MAX_SECRX_POLL; i++) {
3271                 secrxreg = IXGBE_READ_REG(hw, IXGBE_SECRXSTAT);
3272                 if (secrxreg & IXGBE_SECRXSTAT_SECRX_RDY)
3273                         break;
3274                 else
3275                         /* Use interrupt-safe sleep just in case */
3276                         usec_delay(1000);
3277         }
3278
3279         /* For informational purposes only */
3280         if (i >= IXGBE_MAX_SECRX_POLL)
3281                 DEBUGOUT("Rx unit being enabled before security "
3282                          "path fully disabled.  Continuing with init.\n");
3283
3284         return IXGBE_SUCCESS;
3285 }
3286
3287 /**
3288  *  prot_autoc_read_generic - Hides MAC differences needed for AUTOC read
3289  *  @hw: pointer to hardware structure
3290  *  @reg_val: Value we read from AUTOC
3291  *
3292  *  The default case requires no protection so just to the register read.
3293  */
3294 s32 prot_autoc_read_generic(struct ixgbe_hw *hw, bool *locked, u32 *reg_val)
3295 {
3296         *locked = FALSE;
3297         *reg_val = IXGBE_READ_REG(hw, IXGBE_AUTOC);
3298         return IXGBE_SUCCESS;
3299 }
3300
3301 /**
3302  * prot_autoc_write_generic - Hides MAC differences needed for AUTOC write
3303  * @hw: pointer to hardware structure
3304  * @reg_val: value to write to AUTOC
3305  * @locked: bool to indicate whether the SW/FW lock was already taken by
3306  *           previous read.
3307  *
3308  * The default case requires no protection so just to the register write.
3309  */
3310 s32 prot_autoc_write_generic(struct ixgbe_hw *hw, u32 reg_val, bool locked)
3311 {
3312         UNREFERENCED_1PARAMETER(locked);
3313
3314         IXGBE_WRITE_REG(hw, IXGBE_AUTOC, reg_val);
3315         return IXGBE_SUCCESS;
3316 }
3317
3318 /**
3319  *  ixgbe_enable_sec_rx_path_generic - Enables the receive data path
3320  *  @hw: pointer to hardware structure
3321  *
3322  *  Enables the receive data path.
3323  **/
3324 s32 ixgbe_enable_sec_rx_path_generic(struct ixgbe_hw *hw)
3325 {
3326         int secrxreg;
3327
3328         DEBUGFUNC("ixgbe_enable_sec_rx_path_generic");
3329
3330         secrxreg = IXGBE_READ_REG(hw, IXGBE_SECRXCTRL);
3331         secrxreg &= ~IXGBE_SECRXCTRL_RX_DIS;
3332         IXGBE_WRITE_REG(hw, IXGBE_SECRXCTRL, secrxreg);
3333         IXGBE_WRITE_FLUSH(hw);
3334
3335         return IXGBE_SUCCESS;
3336 }
3337
3338 /**
3339  *  ixgbe_enable_rx_dma_generic - Enable the Rx DMA unit
3340  *  @hw: pointer to hardware structure
3341  *  @regval: register value to write to RXCTRL
3342  *
3343  *  Enables the Rx DMA unit
3344  **/
3345 s32 ixgbe_enable_rx_dma_generic(struct ixgbe_hw *hw, u32 regval)
3346 {
3347         DEBUGFUNC("ixgbe_enable_rx_dma_generic");
3348
3349         if (regval & IXGBE_RXCTRL_RXEN)
3350                 ixgbe_enable_rx(hw);
3351         else
3352                 ixgbe_disable_rx(hw);
3353
3354         return IXGBE_SUCCESS;
3355 }
3356
3357 /**
3358  *  ixgbe_blink_led_start_generic - Blink LED based on index.
3359  *  @hw: pointer to hardware structure
3360  *  @index: led number to blink
3361  **/
3362 s32 ixgbe_blink_led_start_generic(struct ixgbe_hw *hw, u32 index)
3363 {
3364         ixgbe_link_speed speed = 0;
3365         bool link_up = 0;
3366         u32 autoc_reg = 0;
3367         u32 led_reg = IXGBE_READ_REG(hw, IXGBE_LEDCTL);
3368         s32 ret_val = IXGBE_SUCCESS;
3369         bool locked = FALSE;
3370
3371         DEBUGFUNC("ixgbe_blink_led_start_generic");
3372
3373         /*
3374          * Link must be up to auto-blink the LEDs;
3375          * Force it if link is down.
3376          */
3377         hw->mac.ops.check_link(hw, &speed, &link_up, FALSE);
3378
3379         if (!link_up) {
3380                 ret_val = hw->mac.ops.prot_autoc_read(hw, &locked, &autoc_reg);
3381                 if (ret_val != IXGBE_SUCCESS)
3382                         goto out;
3383
3384                 autoc_reg |= IXGBE_AUTOC_AN_RESTART;
3385                 autoc_reg |= IXGBE_AUTOC_FLU;
3386
3387                 ret_val = hw->mac.ops.prot_autoc_write(hw, autoc_reg, locked);
3388                 if (ret_val != IXGBE_SUCCESS)
3389                         goto out;
3390
3391                 IXGBE_WRITE_FLUSH(hw);
3392                 msec_delay(10);
3393         }
3394
3395         led_reg &= ~IXGBE_LED_MODE_MASK(index);
3396         led_reg |= IXGBE_LED_BLINK(index);
3397         IXGBE_WRITE_REG(hw, IXGBE_LEDCTL, led_reg);
3398         IXGBE_WRITE_FLUSH(hw);
3399
3400 out:
3401         return ret_val;
3402 }
3403
3404 /**
3405  *  ixgbe_blink_led_stop_generic - Stop blinking LED based on index.
3406  *  @hw: pointer to hardware structure
3407  *  @index: led number to stop blinking
3408  **/
3409 s32 ixgbe_blink_led_stop_generic(struct ixgbe_hw *hw, u32 index)
3410 {
3411         u32 autoc_reg = 0;
3412         u32 led_reg = IXGBE_READ_REG(hw, IXGBE_LEDCTL);
3413         s32 ret_val = IXGBE_SUCCESS;
3414         bool locked = FALSE;
3415
3416         DEBUGFUNC("ixgbe_blink_led_stop_generic");
3417
3418         ret_val = hw->mac.ops.prot_autoc_read(hw, &locked, &autoc_reg);
3419         if (ret_val != IXGBE_SUCCESS)
3420                 goto out;
3421
3422         autoc_reg &= ~IXGBE_AUTOC_FLU;
3423         autoc_reg |= IXGBE_AUTOC_AN_RESTART;
3424
3425         ret_val = hw->mac.ops.prot_autoc_write(hw, autoc_reg, locked);
3426         if (ret_val != IXGBE_SUCCESS)
3427                 goto out;
3428
3429         led_reg &= ~IXGBE_LED_MODE_MASK(index);
3430         led_reg &= ~IXGBE_LED_BLINK(index);
3431         led_reg |= IXGBE_LED_LINK_ACTIVE << IXGBE_LED_MODE_SHIFT(index);
3432         IXGBE_WRITE_REG(hw, IXGBE_LEDCTL, led_reg);
3433         IXGBE_WRITE_FLUSH(hw);
3434
3435 out:
3436         return ret_val;
3437 }
3438
3439 /**
3440  *  ixgbe_get_san_mac_addr_offset - Get SAN MAC address offset from the EEPROM
3441  *  @hw: pointer to hardware structure
3442  *  @san_mac_offset: SAN MAC address offset
3443  *
3444  *  This function will read the EEPROM location for the SAN MAC address
3445  *  pointer, and returns the value at that location.  This is used in both
3446  *  get and set mac_addr routines.
3447  **/
3448 static s32 ixgbe_get_san_mac_addr_offset(struct ixgbe_hw *hw,
3449                                          u16 *san_mac_offset)
3450 {
3451         s32 ret_val;
3452
3453         DEBUGFUNC("ixgbe_get_san_mac_addr_offset");
3454
3455         /*
3456          * First read the EEPROM pointer to see if the MAC addresses are
3457          * available.
3458          */
3459         ret_val = hw->eeprom.ops.read(hw, IXGBE_SAN_MAC_ADDR_PTR,
3460                                       san_mac_offset);
3461         if (ret_val) {
3462                 ERROR_REPORT2(IXGBE_ERROR_INVALID_STATE,
3463                               "eeprom at offset %d failed",
3464                               IXGBE_SAN_MAC_ADDR_PTR);
3465         }
3466
3467         return ret_val;
3468 }
3469
3470 /**
3471  *  ixgbe_get_san_mac_addr_generic - SAN MAC address retrieval from the EEPROM
3472  *  @hw: pointer to hardware structure
3473  *  @san_mac_addr: SAN MAC address
3474  *
3475  *  Reads the SAN MAC address from the EEPROM, if it's available.  This is
3476  *  per-port, so set_lan_id() must be called before reading the addresses.
3477  *  set_lan_id() is called by identify_sfp(), but this cannot be relied
3478  *  upon for non-SFP connections, so we must call it here.
3479  **/
3480 s32 ixgbe_get_san_mac_addr_generic(struct ixgbe_hw *hw, u8 *san_mac_addr)
3481 {
3482         u16 san_mac_data, san_mac_offset;
3483         u8 i;
3484         s32 ret_val;
3485
3486         DEBUGFUNC("ixgbe_get_san_mac_addr_generic");
3487
3488         /*
3489          * First read the EEPROM pointer to see if the MAC addresses are
3490          * available.  If they're not, no point in calling set_lan_id() here.
3491          */
3492         ret_val = ixgbe_get_san_mac_addr_offset(hw, &san_mac_offset);
3493         if (ret_val || san_mac_offset == 0 || san_mac_offset == 0xFFFF)
3494                 goto san_mac_addr_out;
3495
3496         /* make sure we know which port we need to program */
3497         hw->mac.ops.set_lan_id(hw);
3498         /* apply the port offset to the address offset */
3499         (hw->bus.func) ? (san_mac_offset += IXGBE_SAN_MAC_ADDR_PORT1_OFFSET) :
3500                          (san_mac_offset += IXGBE_SAN_MAC_ADDR_PORT0_OFFSET);
3501         for (i = 0; i < 3; i++) {
3502                 ret_val = hw->eeprom.ops.read(hw, san_mac_offset,
3503                                               &san_mac_data);
3504                 if (ret_val) {
3505                         ERROR_REPORT2(IXGBE_ERROR_INVALID_STATE,
3506                                       "eeprom read at offset %d failed",
3507                                       san_mac_offset);
3508                         goto san_mac_addr_out;
3509                 }
3510                 san_mac_addr[i * 2] = (u8)(san_mac_data);
3511                 san_mac_addr[i * 2 + 1] = (u8)(san_mac_data >> 8);
3512                 san_mac_offset++;
3513         }
3514         return IXGBE_SUCCESS;
3515
3516 san_mac_addr_out:
3517         /*
3518          * No addresses available in this EEPROM.  It's not an
3519          * error though, so just wipe the local address and return.
3520          */
3521         for (i = 0; i < 6; i++)
3522                 san_mac_addr[i] = 0xFF;
3523         return IXGBE_SUCCESS;
3524 }
3525
3526 /**
3527  *  ixgbe_set_san_mac_addr_generic - Write the SAN MAC address to the EEPROM
3528  *  @hw: pointer to hardware structure
3529  *  @san_mac_addr: SAN MAC address
3530  *
3531  *  Write a SAN MAC address to the EEPROM.
3532  **/
3533 s32 ixgbe_set_san_mac_addr_generic(struct ixgbe_hw *hw, u8 *san_mac_addr)
3534 {
3535         s32 ret_val;
3536         u16 san_mac_data, san_mac_offset;
3537         u8 i;
3538
3539         DEBUGFUNC("ixgbe_set_san_mac_addr_generic");
3540
3541         /* Look for SAN mac address pointer.  If not defined, return */
3542         ret_val = ixgbe_get_san_mac_addr_offset(hw, &san_mac_offset);
3543         if (ret_val || san_mac_offset == 0 || san_mac_offset == 0xFFFF)
3544                 return IXGBE_ERR_NO_SAN_ADDR_PTR;
3545
3546         /* Make sure we know which port we need to write */
3547         hw->mac.ops.set_lan_id(hw);
3548         /* Apply the port offset to the address offset */
3549         (hw->bus.func) ? (san_mac_offset += IXGBE_SAN_MAC_ADDR_PORT1_OFFSET) :
3550                          (san_mac_offset += IXGBE_SAN_MAC_ADDR_PORT0_OFFSET);
3551
3552         for (i = 0; i < 3; i++) {
3553                 san_mac_data = (u16)((u16)(san_mac_addr[i * 2 + 1]) << 8);
3554                 san_mac_data |= (u16)(san_mac_addr[i * 2]);
3555                 hw->eeprom.ops.write(hw, san_mac_offset, san_mac_data);
3556                 san_mac_offset++;
3557         }
3558
3559         return IXGBE_SUCCESS;
3560 }
3561
3562 /**
3563  *  ixgbe_get_pcie_msix_count_generic - Gets MSI-X vector count
3564  *  @hw: pointer to hardware structure
3565  *
3566  *  Read PCIe configuration space, and get the MSI-X vector count from
3567  *  the capabilities table.
3568  **/
3569 u16 ixgbe_get_pcie_msix_count_generic(struct ixgbe_hw *hw)
3570 {
3571         u16 msix_count = 1;
3572         u16 max_msix_count;
3573         u16 pcie_offset;
3574
3575         switch (hw->mac.type) {
3576         case ixgbe_mac_82598EB:
3577                 pcie_offset = IXGBE_PCIE_MSIX_82598_CAPS;
3578                 max_msix_count = IXGBE_MAX_MSIX_VECTORS_82598;
3579                 break;
3580         case ixgbe_mac_82599EB:
3581         case ixgbe_mac_X540:
3582         case ixgbe_mac_X550:
3583         case ixgbe_mac_X550EM_x:
3584                 pcie_offset = IXGBE_PCIE_MSIX_82599_CAPS;
3585                 max_msix_count = IXGBE_MAX_MSIX_VECTORS_82599;
3586                 break;
3587         default:
3588                 return msix_count;
3589         }
3590
3591         DEBUGFUNC("ixgbe_get_pcie_msix_count_generic");
3592         msix_count = IXGBE_READ_PCIE_WORD(hw, pcie_offset);
3593         if (IXGBE_REMOVED(hw->hw_addr))
3594                 msix_count = 0;
3595         msix_count &= IXGBE_PCIE_MSIX_TBL_SZ_MASK;
3596
3597         /* MSI-X count is zero-based in HW */
3598         msix_count++;
3599
3600         if (msix_count > max_msix_count)
3601                 msix_count = max_msix_count;
3602
3603         return msix_count;
3604 }
3605
3606 /**
3607  *  ixgbe_insert_mac_addr_generic - Find a RAR for this mac address
3608  *  @hw: pointer to hardware structure
3609  *  @addr: Address to put into receive address register
3610  *  @vmdq: VMDq pool to assign
3611  *
3612  *  Puts an ethernet address into a receive address register, or
3613  *  finds the rar that it is aleady in; adds to the pool list
3614  **/
3615 s32 ixgbe_insert_mac_addr_generic(struct ixgbe_hw *hw, u8 *addr, u32 vmdq)
3616 {
3617         static const u32 NO_EMPTY_RAR_FOUND = 0xFFFFFFFF;
3618         u32 first_empty_rar = NO_EMPTY_RAR_FOUND;
3619         u32 rar;
3620         u32 rar_low, rar_high;
3621         u32 addr_low, addr_high;
3622
3623         DEBUGFUNC("ixgbe_insert_mac_addr_generic");
3624
3625         /* swap bytes for HW little endian */
3626         addr_low  = addr[0] | (addr[1] << 8)
3627                             | (addr[2] << 16)
3628                             | (addr[3] << 24);
3629         addr_high = addr[4] | (addr[5] << 8);
3630
3631         /*
3632          * Either find the mac_id in rar or find the first empty space.
3633          * rar_highwater points to just after the highest currently used
3634          * rar in order to shorten the search.  It grows when we add a new
3635          * rar to the top.
3636          */
3637         for (rar = 0; rar < hw->mac.rar_highwater; rar++) {
3638                 rar_high = IXGBE_READ_REG(hw, IXGBE_RAH(rar));
3639
3640                 if (((IXGBE_RAH_AV & rar_high) == 0)
3641                     && first_empty_rar == NO_EMPTY_RAR_FOUND) {
3642                         first_empty_rar = rar;
3643                 } else if ((rar_high & 0xFFFF) == addr_high) {
3644                         rar_low = IXGBE_READ_REG(hw, IXGBE_RAL(rar));
3645                         if (rar_low == addr_low)
3646                                 break;    /* found it already in the rars */
3647                 }
3648         }
3649
3650         if (rar < hw->mac.rar_highwater) {
3651                 /* already there so just add to the pool bits */
3652                 ixgbe_set_vmdq(hw, rar, vmdq);
3653         } else if (first_empty_rar != NO_EMPTY_RAR_FOUND) {
3654                 /* stick it into first empty RAR slot we found */
3655                 rar = first_empty_rar;
3656                 ixgbe_set_rar(hw, rar, addr, vmdq, IXGBE_RAH_AV);
3657         } else if (rar == hw->mac.rar_highwater) {
3658                 /* add it to the top of the list and inc the highwater mark */
3659                 ixgbe_set_rar(hw, rar, addr, vmdq, IXGBE_RAH_AV);
3660                 hw->mac.rar_highwater++;
3661         } else if (rar >= hw->mac.num_rar_entries) {
3662                 return IXGBE_ERR_INVALID_MAC_ADDR;
3663         }
3664
3665         /*
3666          * If we found rar[0], make sure the default pool bit (we use pool 0)
3667          * remains cleared to be sure default pool packets will get delivered
3668          */
3669         if (rar == 0)
3670                 ixgbe_clear_vmdq(hw, rar, 0);
3671
3672         return rar;
3673 }
3674
3675 /**
3676  *  ixgbe_clear_vmdq_generic - Disassociate a VMDq pool index from a rx address
3677  *  @hw: pointer to hardware struct
3678  *  @rar: receive address register index to disassociate
3679  *  @vmdq: VMDq pool index to remove from the rar
3680  **/
3681 s32 ixgbe_clear_vmdq_generic(struct ixgbe_hw *hw, u32 rar, u32 vmdq)
3682 {
3683         u32 mpsar_lo, mpsar_hi;
3684         u32 rar_entries = hw->mac.num_rar_entries;
3685
3686         DEBUGFUNC("ixgbe_clear_vmdq_generic");
3687
3688         /* Make sure we are using a valid rar index range */
3689         if (rar >= rar_entries) {
3690                 ERROR_REPORT2(IXGBE_ERROR_ARGUMENT,
3691                              "RAR index %d is out of range.\n", rar);
3692                 return IXGBE_ERR_INVALID_ARGUMENT;
3693         }
3694
3695         mpsar_lo = IXGBE_READ_REG(hw, IXGBE_MPSAR_LO(rar));
3696         mpsar_hi = IXGBE_READ_REG(hw, IXGBE_MPSAR_HI(rar));
3697
3698         if (IXGBE_REMOVED(hw->hw_addr))
3699                 goto done;
3700
3701         if (!mpsar_lo && !mpsar_hi)
3702                 goto done;
3703
3704         if (vmdq == IXGBE_CLEAR_VMDQ_ALL) {
3705                 if (mpsar_lo) {
3706                         IXGBE_WRITE_REG(hw, IXGBE_MPSAR_LO(rar), 0);
3707                         mpsar_lo = 0;
3708                 }
3709                 if (mpsar_hi) {
3710                         IXGBE_WRITE_REG(hw, IXGBE_MPSAR_HI(rar), 0);
3711                         mpsar_hi = 0;
3712                 }
3713         } else if (vmdq < 32) {
3714                 mpsar_lo &= ~(1 << vmdq);
3715                 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_LO(rar), mpsar_lo);
3716         } else {
3717                 mpsar_hi &= ~(1 << (vmdq - 32));
3718                 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_HI(rar), mpsar_hi);
3719         }
3720
3721         /* was that the last pool using this rar? */
3722         if (mpsar_lo == 0 && mpsar_hi == 0 && rar != 0)
3723                 hw->mac.ops.clear_rar(hw, rar);
3724 done:
3725         return IXGBE_SUCCESS;
3726 }
3727
3728 /**
3729  *  ixgbe_set_vmdq_generic - Associate a VMDq pool index with a rx address
3730  *  @hw: pointer to hardware struct
3731  *  @rar: receive address register index to associate with a VMDq index
3732  *  @vmdq: VMDq pool index
3733  **/
3734 s32 ixgbe_set_vmdq_generic(struct ixgbe_hw *hw, u32 rar, u32 vmdq)
3735 {
3736         u32 mpsar;
3737         u32 rar_entries = hw->mac.num_rar_entries;
3738
3739         DEBUGFUNC("ixgbe_set_vmdq_generic");
3740
3741         /* Make sure we are using a valid rar index range */
3742         if (rar >= rar_entries) {
3743                 ERROR_REPORT2(IXGBE_ERROR_ARGUMENT,
3744                              "RAR index %d is out of range.\n", rar);
3745                 return IXGBE_ERR_INVALID_ARGUMENT;
3746         }
3747
3748         if (vmdq < 32) {
3749                 mpsar = IXGBE_READ_REG(hw, IXGBE_MPSAR_LO(rar));
3750                 mpsar |= 1 << vmdq;
3751                 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_LO(rar), mpsar);
3752         } else {
3753                 mpsar = IXGBE_READ_REG(hw, IXGBE_MPSAR_HI(rar));
3754                 mpsar |= 1 << (vmdq - 32);
3755                 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_HI(rar), mpsar);
3756         }
3757         return IXGBE_SUCCESS;
3758 }
3759
3760 /**
3761  *  This function should only be involved in the IOV mode.
3762  *  In IOV mode, Default pool is next pool after the number of
3763  *  VFs advertized and not 0.
3764  *  MPSAR table needs to be updated for SAN_MAC RAR [hw->mac.san_mac_rar_index]
3765  *
3766  *  ixgbe_set_vmdq_san_mac - Associate default VMDq pool index with a rx address
3767  *  @hw: pointer to hardware struct
3768  *  @vmdq: VMDq pool index
3769  **/
3770 s32 ixgbe_set_vmdq_san_mac_generic(struct ixgbe_hw *hw, u32 vmdq)
3771 {
3772         u32 rar = hw->mac.san_mac_rar_index;
3773
3774         DEBUGFUNC("ixgbe_set_vmdq_san_mac");
3775
3776         if (vmdq < 32) {
3777                 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_LO(rar), 1 << vmdq);
3778                 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_HI(rar), 0);
3779         } else {
3780                 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_LO(rar), 0);
3781                 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_HI(rar), 1 << (vmdq - 32));
3782         }
3783
3784         return IXGBE_SUCCESS;
3785 }
3786
3787 /**
3788  *  ixgbe_init_uta_tables_generic - Initialize the Unicast Table Array
3789  *  @hw: pointer to hardware structure
3790  **/
3791 s32 ixgbe_init_uta_tables_generic(struct ixgbe_hw *hw)
3792 {
3793         int i;
3794
3795         DEBUGFUNC("ixgbe_init_uta_tables_generic");
3796         DEBUGOUT(" Clearing UTA\n");
3797
3798         for (i = 0; i < 128; i++)
3799                 IXGBE_WRITE_REG(hw, IXGBE_UTA(i), 0);
3800
3801         return IXGBE_SUCCESS;
3802 }
3803
3804 /**
3805  *  ixgbe_find_vlvf_slot - find the vlanid or the first empty slot
3806  *  @hw: pointer to hardware structure
3807  *  @vlan: VLAN id to write to VLAN filter
3808  *
3809  *  return the VLVF index where this VLAN id should be placed
3810  *
3811  **/
3812 s32 ixgbe_find_vlvf_slot(struct ixgbe_hw *hw, u32 vlan)
3813 {
3814         u32 bits = 0;
3815         u32 first_empty_slot = 0;
3816         s32 regindex;
3817
3818         /* short cut the special case */
3819         if (vlan == 0)
3820                 return 0;
3821
3822         /*
3823           * Search for the vlan id in the VLVF entries. Save off the first empty
3824           * slot found along the way
3825           */
3826         for (regindex = 1; regindex < IXGBE_VLVF_ENTRIES; regindex++) {
3827                 bits = IXGBE_READ_REG(hw, IXGBE_VLVF(regindex));
3828                 if (!bits && !(first_empty_slot))
3829                         first_empty_slot = regindex;
3830                 else if ((bits & 0x0FFF) == vlan)
3831                         break;
3832         }
3833
3834         /*
3835           * If regindex is less than IXGBE_VLVF_ENTRIES, then we found the vlan
3836           * in the VLVF. Else use the first empty VLVF register for this
3837           * vlan id.
3838           */
3839         if (regindex >= IXGBE_VLVF_ENTRIES) {
3840                 if (first_empty_slot)
3841                         regindex = first_empty_slot;
3842                 else {
3843                         ERROR_REPORT1(IXGBE_ERROR_SOFTWARE,
3844                                      "No space in VLVF.\n");
3845                         regindex = IXGBE_ERR_NO_SPACE;
3846                 }
3847         }
3848
3849         return regindex;
3850 }
3851
3852 /**
3853  *  ixgbe_set_vfta_generic - Set VLAN filter table
3854  *  @hw: pointer to hardware structure
3855  *  @vlan: VLAN id to write to VLAN filter
3856  *  @vind: VMDq output index that maps queue to VLAN id in VFVFB
3857  *  @vlan_on: boolean flag to turn on/off VLAN in VFVF
3858  *
3859  *  Turn on/off specified VLAN in the VLAN filter table.
3860  **/
3861 s32 ixgbe_set_vfta_generic(struct ixgbe_hw *hw, u32 vlan, u32 vind,
3862                            bool vlan_on)
3863 {
3864         s32 regindex;
3865         u32 bitindex;
3866         u32 vfta;
3867         u32 targetbit;
3868         s32 ret_val = IXGBE_SUCCESS;
3869         bool vfta_changed = FALSE;
3870
3871         DEBUGFUNC("ixgbe_set_vfta_generic");
3872
3873         if (vlan > 4095)
3874                 return IXGBE_ERR_PARAM;
3875
3876         /*
3877          * this is a 2 part operation - first the VFTA, then the
3878          * VLVF and VLVFB if VT Mode is set
3879          * We don't write the VFTA until we know the VLVF part succeeded.
3880          */
3881
3882         /* Part 1
3883          * The VFTA is a bitstring made up of 128 32-bit registers
3884          * that enable the particular VLAN id, much like the MTA:
3885          *    bits[11-5]: which register
3886          *    bits[4-0]:  which bit in the register
3887          */
3888         regindex = (vlan >> 5) & 0x7F;
3889         bitindex = vlan & 0x1F;
3890         targetbit = (1 << bitindex);
3891         vfta = IXGBE_READ_REG(hw, IXGBE_VFTA(regindex));
3892
3893         if (vlan_on) {
3894                 if (!(vfta & targetbit)) {
3895                         vfta |= targetbit;
3896                         vfta_changed = TRUE;
3897                 }
3898         } else {
3899                 if ((vfta & targetbit)) {
3900                         vfta &= ~targetbit;
3901                         vfta_changed = TRUE;
3902                 }
3903         }
3904
3905         /* Part 2
3906          * Call ixgbe_set_vlvf_generic to set VLVFB and VLVF
3907          */
3908         ret_val = ixgbe_set_vlvf_generic(hw, vlan, vind, vlan_on,
3909                                          &vfta_changed);
3910         if (ret_val != IXGBE_SUCCESS)
3911                 return ret_val;
3912
3913         if (vfta_changed)
3914                 IXGBE_WRITE_REG(hw, IXGBE_VFTA(regindex), vfta);
3915
3916         return IXGBE_SUCCESS;
3917 }
3918
3919 /**
3920  *  ixgbe_set_vlvf_generic - Set VLAN Pool Filter
3921  *  @hw: pointer to hardware structure
3922  *  @vlan: VLAN id to write to VLAN filter
3923  *  @vind: VMDq output index that maps queue to VLAN id in VFVFB
3924  *  @vlan_on: boolean flag to turn on/off VLAN in VFVF
3925  *  @vfta_changed: pointer to boolean flag which indicates whether VFTA
3926  *                 should be changed
3927  *
3928  *  Turn on/off specified bit in VLVF table.
3929  **/
3930 s32 ixgbe_set_vlvf_generic(struct ixgbe_hw *hw, u32 vlan, u32 vind,
3931                             bool vlan_on, bool *vfta_changed)
3932 {
3933         u32 vt;
3934
3935         DEBUGFUNC("ixgbe_set_vlvf_generic");
3936
3937         if (vlan > 4095)
3938                 return IXGBE_ERR_PARAM;
3939
3940         /* If VT Mode is set
3941          *   Either vlan_on
3942          *     make sure the vlan is in VLVF
3943          *     set the vind bit in the matching VLVFB
3944          *   Or !vlan_on
3945          *     clear the pool bit and possibly the vind
3946          */
3947         vt = IXGBE_READ_REG(hw, IXGBE_VT_CTL);
3948         if (vt & IXGBE_VT_CTL_VT_ENABLE) {
3949                 s32 vlvf_index;
3950                 u32 bits;
3951
3952                 vlvf_index = ixgbe_find_vlvf_slot(hw, vlan);
3953                 if (vlvf_index < 0)
3954                         return vlvf_index;
3955
3956                 if (vlan_on) {
3957                         /* set the pool bit */
3958                         if (vind < 32) {
3959                                 bits = IXGBE_READ_REG(hw,
3960                                                 IXGBE_VLVFB(vlvf_index * 2));
3961                                 bits |= (1 << vind);
3962                                 IXGBE_WRITE_REG(hw,
3963                                                 IXGBE_VLVFB(vlvf_index * 2),
3964                                                 bits);
3965                         } else {
3966                                 bits = IXGBE_READ_REG(hw,
3967                                         IXGBE_VLVFB((vlvf_index * 2) + 1));
3968                                 bits |= (1 << (vind - 32));
3969                                 IXGBE_WRITE_REG(hw,
3970                                         IXGBE_VLVFB((vlvf_index * 2) + 1),
3971                                         bits);
3972                         }
3973                 } else {
3974                         /* clear the pool bit */
3975                         if (vind < 32) {
3976                                 bits = IXGBE_READ_REG(hw,
3977                                                 IXGBE_VLVFB(vlvf_index * 2));
3978                                 bits &= ~(1 << vind);
3979                                 IXGBE_WRITE_REG(hw,
3980                                                 IXGBE_VLVFB(vlvf_index * 2),
3981                                                 bits);
3982                                 bits |= IXGBE_READ_REG(hw,
3983                                         IXGBE_VLVFB((vlvf_index * 2) + 1));
3984                         } else {
3985                                 bits = IXGBE_READ_REG(hw,
3986                                         IXGBE_VLVFB((vlvf_index * 2) + 1));
3987                                 bits &= ~(1 << (vind - 32));
3988                                 IXGBE_WRITE_REG(hw,
3989                                         IXGBE_VLVFB((vlvf_index * 2) + 1),
3990                                         bits);
3991                                 bits |= IXGBE_READ_REG(hw,
3992                                                 IXGBE_VLVFB(vlvf_index * 2));
3993                         }
3994                 }
3995
3996                 /*
3997                  * If there are still bits set in the VLVFB registers
3998                  * for the VLAN ID indicated we need to see if the
3999                  * caller is requesting that we clear the VFTA entry bit.
4000                  * If the caller has requested that we clear the VFTA
4001                  * entry bit but there are still pools/VFs using this VLAN
4002                  * ID entry then ignore the request.  We're not worried
4003                  * about the case where we're turning the VFTA VLAN ID
4004                  * entry bit on, only when requested to turn it off as
4005                  * there may be multiple pools and/or VFs using the
4006                  * VLAN ID entry.  In that case we cannot clear the
4007                  * VFTA bit until all pools/VFs using that VLAN ID have also
4008                  * been cleared.  This will be indicated by "bits" being
4009                  * zero.
4010                  */
4011                 if (bits) {
4012                         IXGBE_WRITE_REG(hw, IXGBE_VLVF(vlvf_index),
4013                                         (IXGBE_VLVF_VIEN | vlan));
4014                         if ((!vlan_on) && (vfta_changed != NULL)) {
4015                                 /* someone wants to clear the vfta entry
4016                                  * but some pools/VFs are still using it.
4017                                  * Ignore it. */
4018                                 *vfta_changed = FALSE;
4019                         }
4020                 } else
4021                         IXGBE_WRITE_REG(hw, IXGBE_VLVF(vlvf_index), 0);
4022         }
4023
4024         return IXGBE_SUCCESS;
4025 }
4026
4027 /**
4028  *  ixgbe_clear_vfta_generic - Clear VLAN filter table
4029  *  @hw: pointer to hardware structure
4030  *
4031  *  Clears the VLAN filer table, and the VMDq index associated with the filter
4032  **/
4033 s32 ixgbe_clear_vfta_generic(struct ixgbe_hw *hw)
4034 {
4035         u32 offset;
4036
4037         DEBUGFUNC("ixgbe_clear_vfta_generic");
4038
4039         for (offset = 0; offset < hw->mac.vft_size; offset++)
4040                 IXGBE_WRITE_REG(hw, IXGBE_VFTA(offset), 0);
4041
4042         for (offset = 0; offset < IXGBE_VLVF_ENTRIES; offset++) {
4043                 IXGBE_WRITE_REG(hw, IXGBE_VLVF(offset), 0);
4044                 IXGBE_WRITE_REG(hw, IXGBE_VLVFB(offset * 2), 0);
4045                 IXGBE_WRITE_REG(hw, IXGBE_VLVFB((offset * 2) + 1), 0);
4046         }
4047
4048         return IXGBE_SUCCESS;
4049 }
4050
4051 /**
4052  *  ixgbe_check_mac_link_generic - Determine link and speed status
4053  *  @hw: pointer to hardware structure
4054  *  @speed: pointer to link speed
4055  *  @link_up: TRUE when link is up
4056  *  @link_up_wait_to_complete: bool used to wait for link up or not
4057  *
4058  *  Reads the links register to determine if link is up and the current speed
4059  **/
4060 s32 ixgbe_check_mac_link_generic(struct ixgbe_hw *hw, ixgbe_link_speed *speed,
4061                                  bool *link_up, bool link_up_wait_to_complete)
4062 {
4063         u32 links_reg, links_orig;
4064         u32 i;
4065
4066         DEBUGFUNC("ixgbe_check_mac_link_generic");
4067
4068         /* clear the old state */
4069         links_orig = IXGBE_READ_REG(hw, IXGBE_LINKS);
4070
4071         links_reg = IXGBE_READ_REG(hw, IXGBE_LINKS);
4072
4073         if (links_orig != links_reg) {
4074                 DEBUGOUT2("LINKS changed from %08X to %08X\n",
4075                           links_orig, links_reg);
4076         }
4077
4078         if (link_up_wait_to_complete) {
4079                 for (i = 0; i < hw->mac.max_link_up_time; i++) {
4080                         if (links_reg & IXGBE_LINKS_UP) {
4081                                 *link_up = TRUE;
4082                                 break;
4083                         } else {
4084                                 *link_up = FALSE;
4085                         }
4086                         msec_delay(100);
4087                         links_reg = IXGBE_READ_REG(hw, IXGBE_LINKS);
4088                 }
4089         } else {
4090                 if (links_reg & IXGBE_LINKS_UP)
4091                         *link_up = TRUE;
4092                 else
4093                         *link_up = FALSE;
4094         }
4095
4096         switch (links_reg & IXGBE_LINKS_SPEED_82599) {
4097         case IXGBE_LINKS_SPEED_10G_82599:
4098                 *speed = IXGBE_LINK_SPEED_10GB_FULL;
4099                 if (hw->mac.type >= ixgbe_mac_X550) {
4100                         if (links_reg & IXGBE_LINKS_SPEED_NON_STD)
4101                                 *speed = IXGBE_LINK_SPEED_2_5GB_FULL;
4102                 }
4103                 break;
4104         case IXGBE_LINKS_SPEED_1G_82599:
4105                 *speed = IXGBE_LINK_SPEED_1GB_FULL;
4106                 break;
4107         case IXGBE_LINKS_SPEED_100_82599:
4108                 *speed = IXGBE_LINK_SPEED_100_FULL;
4109                 if (hw->mac.type >= ixgbe_mac_X550) {
4110                         if (links_reg & IXGBE_LINKS_SPEED_NON_STD)
4111                                 *speed = IXGBE_LINK_SPEED_5GB_FULL;
4112                 }
4113                 break;
4114         default:
4115                 *speed = IXGBE_LINK_SPEED_UNKNOWN;
4116         }
4117
4118         return IXGBE_SUCCESS;
4119 }
4120
4121 /**
4122  *  ixgbe_get_wwn_prefix_generic - Get alternative WWNN/WWPN prefix from
4123  *  the EEPROM
4124  *  @hw: pointer to hardware structure
4125  *  @wwnn_prefix: the alternative WWNN prefix
4126  *  @wwpn_prefix: the alternative WWPN prefix
4127  *
4128  *  This function will read the EEPROM from the alternative SAN MAC address
4129  *  block to check the support for the alternative WWNN/WWPN prefix support.
4130  **/
4131 s32 ixgbe_get_wwn_prefix_generic(struct ixgbe_hw *hw, u16 *wwnn_prefix,
4132                                  u16 *wwpn_prefix)
4133 {
4134         u16 offset, caps;
4135         u16 alt_san_mac_blk_offset;
4136
4137         DEBUGFUNC("ixgbe_get_wwn_prefix_generic");
4138
4139         /* clear output first */
4140         *wwnn_prefix = 0xFFFF;
4141         *wwpn_prefix = 0xFFFF;
4142
4143         /* check if alternative SAN MAC is supported */
4144         offset = IXGBE_ALT_SAN_MAC_ADDR_BLK_PTR;
4145         if (hw->eeprom.ops.read(hw, offset, &alt_san_mac_blk_offset))
4146                 goto wwn_prefix_err;
4147
4148         if ((alt_san_mac_blk_offset == 0) ||
4149             (alt_san_mac_blk_offset == 0xFFFF))
4150                 goto wwn_prefix_out;
4151
4152         /* check capability in alternative san mac address block */
4153         offset = alt_san_mac_blk_offset + IXGBE_ALT_SAN_MAC_ADDR_CAPS_OFFSET;
4154         if (hw->eeprom.ops.read(hw, offset, &caps))
4155                 goto wwn_prefix_err;
4156         if (!(caps & IXGBE_ALT_SAN_MAC_ADDR_CAPS_ALTWWN))
4157                 goto wwn_prefix_out;
4158
4159         /* get the corresponding prefix for WWNN/WWPN */
4160         offset = alt_san_mac_blk_offset + IXGBE_ALT_SAN_MAC_ADDR_WWNN_OFFSET;
4161         if (hw->eeprom.ops.read(hw, offset, wwnn_prefix)) {
4162                 ERROR_REPORT2(IXGBE_ERROR_INVALID_STATE,
4163                               "eeprom read at offset %d failed", offset);
4164         }
4165
4166         offset = alt_san_mac_blk_offset + IXGBE_ALT_SAN_MAC_ADDR_WWPN_OFFSET;
4167         if (hw->eeprom.ops.read(hw, offset, wwpn_prefix))
4168                 goto wwn_prefix_err;
4169
4170 wwn_prefix_out:
4171         return IXGBE_SUCCESS;
4172
4173 wwn_prefix_err:
4174         ERROR_REPORT2(IXGBE_ERROR_INVALID_STATE,
4175                       "eeprom read at offset %d failed", offset);
4176         return IXGBE_SUCCESS;
4177 }
4178
4179 /**
4180  *  ixgbe_get_fcoe_boot_status_generic - Get FCOE boot status from EEPROM
4181  *  @hw: pointer to hardware structure
4182  *  @bs: the fcoe boot status
4183  *
4184  *  This function will read the FCOE boot status from the iSCSI FCOE block
4185  **/
4186 s32 ixgbe_get_fcoe_boot_status_generic(struct ixgbe_hw *hw, u16 *bs)
4187 {
4188         u16 offset, caps, flags;
4189         s32 status;
4190
4191         DEBUGFUNC("ixgbe_get_fcoe_boot_status_generic");
4192
4193         /* clear output first */
4194         *bs = ixgbe_fcoe_bootstatus_unavailable;
4195
4196         /* check if FCOE IBA block is present */
4197         offset = IXGBE_FCOE_IBA_CAPS_BLK_PTR;
4198         status = hw->eeprom.ops.read(hw, offset, &caps);
4199         if (status != IXGBE_SUCCESS)
4200                 goto out;
4201
4202         if (!(caps & IXGBE_FCOE_IBA_CAPS_FCOE))
4203                 goto out;
4204
4205         /* check if iSCSI FCOE block is populated */
4206         status = hw->eeprom.ops.read(hw, IXGBE_ISCSI_FCOE_BLK_PTR, &offset);
4207         if (status != IXGBE_SUCCESS)
4208                 goto out;
4209
4210         if ((offset == 0) || (offset == 0xFFFF))
4211                 goto out;
4212
4213         /* read fcoe flags in iSCSI FCOE block */
4214         offset = offset + IXGBE_ISCSI_FCOE_FLAGS_OFFSET;
4215         status = hw->eeprom.ops.read(hw, offset, &flags);
4216         if (status != IXGBE_SUCCESS)
4217                 goto out;
4218
4219         if (flags & IXGBE_ISCSI_FCOE_FLAGS_ENABLE)
4220                 *bs = ixgbe_fcoe_bootstatus_enabled;
4221         else
4222                 *bs = ixgbe_fcoe_bootstatus_disabled;
4223
4224 out:
4225         return status;
4226 }
4227
4228 /**
4229  *  ixgbe_set_mac_anti_spoofing - Enable/Disable MAC anti-spoofing
4230  *  @hw: pointer to hardware structure
4231  *  @enable: enable or disable switch for anti-spoofing
4232  *  @pf: Physical Function pool - do not enable anti-spoofing for the PF
4233  *
4234  **/
4235 void ixgbe_set_mac_anti_spoofing(struct ixgbe_hw *hw, bool enable, int pf)
4236 {
4237         int j;
4238         int pf_target_reg = pf >> 3;
4239         int pf_target_shift = pf % 8;
4240         u32 pfvfspoof = 0;
4241
4242         if (hw->mac.type == ixgbe_mac_82598EB)
4243                 return;
4244
4245         if (enable)
4246                 pfvfspoof = IXGBE_SPOOF_MACAS_MASK;
4247
4248         /*
4249          * PFVFSPOOF register array is size 8 with 8 bits assigned to
4250          * MAC anti-spoof enables in each register array element.
4251          */
4252         for (j = 0; j < pf_target_reg; j++)
4253                 IXGBE_WRITE_REG(hw, IXGBE_PFVFSPOOF(j), pfvfspoof);
4254
4255         /*
4256          * The PF should be allowed to spoof so that it can support
4257          * emulation mode NICs.  Do not set the bits assigned to the PF
4258          */
4259         pfvfspoof &= (1 << pf_target_shift) - 1;
4260         IXGBE_WRITE_REG(hw, IXGBE_PFVFSPOOF(j), pfvfspoof);
4261
4262         /*
4263          * Remaining pools belong to the PF so they do not need to have
4264          * anti-spoofing enabled.
4265          */
4266         for (j++; j < IXGBE_PFVFSPOOF_REG_COUNT; j++)
4267                 IXGBE_WRITE_REG(hw, IXGBE_PFVFSPOOF(j), 0);
4268 }
4269
4270 /**
4271  *  ixgbe_set_vlan_anti_spoofing - Enable/Disable VLAN anti-spoofing
4272  *  @hw: pointer to hardware structure
4273  *  @enable: enable or disable switch for VLAN anti-spoofing
4274  *  @vf: Virtual Function pool - VF Pool to set for VLAN anti-spoofing
4275  *
4276  **/
4277 void ixgbe_set_vlan_anti_spoofing(struct ixgbe_hw *hw, bool enable, int vf)
4278 {
4279         int vf_target_reg = vf >> 3;
4280         int vf_target_shift = vf % 8 + IXGBE_SPOOF_VLANAS_SHIFT;
4281         u32 pfvfspoof;
4282
4283         if (hw->mac.type == ixgbe_mac_82598EB)
4284                 return;
4285
4286         pfvfspoof = IXGBE_READ_REG(hw, IXGBE_PFVFSPOOF(vf_target_reg));
4287         if (enable)
4288                 pfvfspoof |= (1 << vf_target_shift);
4289         else
4290                 pfvfspoof &= ~(1 << vf_target_shift);
4291         IXGBE_WRITE_REG(hw, IXGBE_PFVFSPOOF(vf_target_reg), pfvfspoof);
4292 }
4293
4294 /**
4295  *  ixgbe_get_device_caps_generic - Get additional device capabilities
4296  *  @hw: pointer to hardware structure
4297  *  @device_caps: the EEPROM word with the extra device capabilities
4298  *
4299  *  This function will read the EEPROM location for the device capabilities,
4300  *  and return the word through device_caps.
4301  **/
4302 s32 ixgbe_get_device_caps_generic(struct ixgbe_hw *hw, u16 *device_caps)
4303 {
4304         DEBUGFUNC("ixgbe_get_device_caps_generic");
4305
4306         hw->eeprom.ops.read(hw, IXGBE_DEVICE_CAPS, device_caps);
4307
4308         return IXGBE_SUCCESS;
4309 }
4310
4311 /**
4312  *  ixgbe_enable_relaxed_ordering_gen2 - Enable relaxed ordering
4313  *  @hw: pointer to hardware structure
4314  *
4315  **/
4316 void ixgbe_enable_relaxed_ordering_gen2(struct ixgbe_hw *hw)
4317 {
4318         u32 regval;
4319         u32 i;
4320
4321         DEBUGFUNC("ixgbe_enable_relaxed_ordering_gen2");
4322
4323         /* Enable relaxed ordering */
4324         for (i = 0; i < hw->mac.max_tx_queues; i++) {
4325                 regval = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL_82599(i));
4326                 regval |= IXGBE_DCA_TXCTRL_DESC_WRO_EN;
4327                 IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL_82599(i), regval);
4328         }
4329
4330         for (i = 0; i < hw->mac.max_rx_queues; i++) {
4331                 regval = IXGBE_READ_REG(hw, IXGBE_DCA_RXCTRL(i));
4332                 regval |= IXGBE_DCA_RXCTRL_DATA_WRO_EN |
4333                           IXGBE_DCA_RXCTRL_HEAD_WRO_EN;
4334                 IXGBE_WRITE_REG(hw, IXGBE_DCA_RXCTRL(i), regval);
4335         }
4336
4337 }
4338
4339 /**
4340  *  ixgbe_calculate_checksum - Calculate checksum for buffer
4341  *  @buffer: pointer to EEPROM
4342  *  @length: size of EEPROM to calculate a checksum for
4343  *  Calculates the checksum for some buffer on a specified length.  The
4344  *  checksum calculated is returned.
4345  **/
4346 u8 ixgbe_calculate_checksum(u8 *buffer, u32 length)
4347 {
4348         u32 i;
4349         u8 sum = 0;
4350
4351         DEBUGFUNC("ixgbe_calculate_checksum");
4352
4353         if (!buffer)
4354                 return 0;
4355
4356         for (i = 0; i < length; i++)
4357                 sum += buffer[i];
4358
4359         return (u8) (0 - sum);
4360 }
4361
4362 /**
4363  *  ixgbe_host_interface_command - Issue command to manageability block
4364  *  @hw: pointer to the HW structure
4365  *  @buffer: contains the command to write and where the return status will
4366  *   be placed
4367  *  @length: length of buffer, must be multiple of 4 bytes
4368  *  @timeout: time in ms to wait for command completion
4369  *  @return_data: read and return data from the buffer (TRUE) or not (FALSE)
4370  *   Needed because FW structures are big endian and decoding of
4371  *   these fields can be 8 bit or 16 bit based on command. Decoding
4372  *   is not easily understood without making a table of commands.
4373  *   So we will leave this up to the caller to read back the data
4374  *   in these cases.
4375  *
4376  *  Communicates with the manageability block.  On success return IXGBE_SUCCESS
4377  *  else return IXGBE_ERR_HOST_INTERFACE_COMMAND.
4378  **/
4379 s32 ixgbe_host_interface_command(struct ixgbe_hw *hw, u32 *buffer,
4380                                  u32 length, u32 timeout, bool return_data)
4381 {
4382         u32 hicr, i, bi, fwsts;
4383         u32 hdr_size = sizeof(struct ixgbe_hic_hdr);
4384         u16 buf_len;
4385         u16 dword_len;
4386
4387         DEBUGFUNC("ixgbe_host_interface_command");
4388
4389         if (length == 0 || length > IXGBE_HI_MAX_BLOCK_BYTE_LENGTH) {
4390                 DEBUGOUT1("Buffer length failure buffersize=%d.\n", length);
4391                 return IXGBE_ERR_HOST_INTERFACE_COMMAND;
4392         }
4393         /* Set bit 9 of FWSTS clearing FW reset indication */
4394         fwsts = IXGBE_READ_REG(hw, IXGBE_FWSTS);
4395         IXGBE_WRITE_REG(hw, IXGBE_FWSTS, fwsts | IXGBE_FWSTS_FWRI);
4396
4397         /* Check that the host interface is enabled. */
4398         hicr = IXGBE_READ_REG(hw, IXGBE_HICR);
4399         if ((hicr & IXGBE_HICR_EN) == 0) {
4400                 DEBUGOUT("IXGBE_HOST_EN bit disabled.\n");
4401                 return IXGBE_ERR_HOST_INTERFACE_COMMAND;
4402         }
4403
4404         /* Calculate length in DWORDs. We must be DWORD aligned */
4405         if ((length % (sizeof(u32))) != 0) {
4406                 DEBUGOUT("Buffer length failure, not aligned to dword");
4407                 return IXGBE_ERR_INVALID_ARGUMENT;
4408         }
4409
4410         dword_len = length >> 2;
4411
4412         /* The device driver writes the relevant command block
4413          * into the ram area.
4414          */
4415         for (i = 0; i < dword_len; i++)
4416                 IXGBE_WRITE_REG_ARRAY(hw, IXGBE_FLEX_MNG,
4417                                       i, IXGBE_CPU_TO_LE32(buffer[i]));
4418
4419         /* Setting this bit tells the ARC that a new command is pending. */
4420         IXGBE_WRITE_REG(hw, IXGBE_HICR, hicr | IXGBE_HICR_C);
4421
4422         for (i = 0; i < timeout; i++) {
4423                 hicr = IXGBE_READ_REG(hw, IXGBE_HICR);
4424                 if (!(hicr & IXGBE_HICR_C))
4425                         break;
4426                 msec_delay(1);
4427         }
4428
4429         /* Check command completion */
4430         if ((timeout != 0 && i == timeout) ||
4431             !(IXGBE_READ_REG(hw, IXGBE_HICR) & IXGBE_HICR_SV)) {
4432                 ERROR_REPORT1(IXGBE_ERROR_CAUTION,
4433                              "Command has failed with no status valid.\n");
4434                 return IXGBE_ERR_HOST_INTERFACE_COMMAND;
4435         }
4436
4437         if (!return_data)
4438                 return 0;
4439
4440         /* Calculate length in DWORDs */
4441         dword_len = hdr_size >> 2;
4442
4443         /* first pull in the header so we know the buffer length */
4444         for (bi = 0; bi < dword_len; bi++) {
4445                 buffer[bi] = IXGBE_READ_REG_ARRAY(hw, IXGBE_FLEX_MNG, bi);
4446                 IXGBE_LE32_TO_CPUS(&buffer[bi]);
4447         }
4448
4449         /* If there is any thing in data position pull it in */
4450         buf_len = ((struct ixgbe_hic_hdr *)buffer)->buf_len;
4451         if (buf_len == 0)
4452                 return 0;
4453
4454         if (length < buf_len + hdr_size) {
4455                 DEBUGOUT("Buffer not large enough for reply message.\n");
4456                 return IXGBE_ERR_HOST_INTERFACE_COMMAND;
4457         }
4458
4459         /* Calculate length in DWORDs, add 3 for odd lengths */
4460         dword_len = (buf_len + 3) >> 2;
4461
4462         /* Pull in the rest of the buffer (bi is where we left off) */
4463         for (; bi <= dword_len; bi++) {
4464                 buffer[bi] = IXGBE_READ_REG_ARRAY(hw, IXGBE_FLEX_MNG, bi);
4465                 IXGBE_LE32_TO_CPUS(&buffer[bi]);
4466         }
4467
4468         return 0;
4469 }
4470
4471 /**
4472  *  ixgbe_set_fw_drv_ver_generic - Sends driver version to firmware
4473  *  @hw: pointer to the HW structure
4474  *  @maj: driver version major number
4475  *  @min: driver version minor number
4476  *  @build: driver version build number
4477  *  @sub: driver version sub build number
4478  *
4479  *  Sends driver version number to firmware through the manageability
4480  *  block.  On success return IXGBE_SUCCESS
4481  *  else returns IXGBE_ERR_SWFW_SYNC when encountering an error acquiring
4482  *  semaphore or IXGBE_ERR_HOST_INTERFACE_COMMAND when command fails.
4483  **/
4484 s32 ixgbe_set_fw_drv_ver_generic(struct ixgbe_hw *hw, u8 maj, u8 min,
4485                                  u8 build, u8 sub)
4486 {
4487         struct ixgbe_hic_drv_info fw_cmd;
4488         int i;
4489         s32 ret_val = IXGBE_SUCCESS;
4490
4491         DEBUGFUNC("ixgbe_set_fw_drv_ver_generic");
4492
4493         if (hw->mac.ops.acquire_swfw_sync(hw, IXGBE_GSSR_SW_MNG_SM)
4494             != IXGBE_SUCCESS) {
4495                 ret_val = IXGBE_ERR_SWFW_SYNC;
4496                 goto out;
4497         }
4498
4499         fw_cmd.hdr.cmd = FW_CEM_CMD_DRIVER_INFO;
4500         fw_cmd.hdr.buf_len = FW_CEM_CMD_DRIVER_INFO_LEN;
4501         fw_cmd.hdr.cmd_or_resp.cmd_resv = FW_CEM_CMD_RESERVED;
4502         fw_cmd.port_num = (u8)hw->bus.func;
4503         fw_cmd.ver_maj = maj;
4504         fw_cmd.ver_min = min;
4505         fw_cmd.ver_build = build;
4506         fw_cmd.ver_sub = sub;
4507         fw_cmd.hdr.checksum = 0;
4508         fw_cmd.hdr.checksum = ixgbe_calculate_checksum((u8 *)&fw_cmd,
4509                                 (FW_CEM_HDR_LEN + fw_cmd.hdr.buf_len));
4510         fw_cmd.pad = 0;
4511         fw_cmd.pad2 = 0;
4512
4513         for (i = 0; i <= FW_CEM_MAX_RETRIES; i++) {
4514                 ret_val = ixgbe_host_interface_command(hw, (u32 *)&fw_cmd,
4515                                                        sizeof(fw_cmd),
4516                                                        IXGBE_HI_COMMAND_TIMEOUT,
4517                                                        TRUE);
4518                 if (ret_val != IXGBE_SUCCESS)
4519                         continue;
4520
4521                 if (fw_cmd.hdr.cmd_or_resp.ret_status ==
4522                     FW_CEM_RESP_STATUS_SUCCESS)
4523                         ret_val = IXGBE_SUCCESS;
4524                 else
4525                         ret_val = IXGBE_ERR_HOST_INTERFACE_COMMAND;
4526
4527                 break;
4528         }
4529
4530         hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_SW_MNG_SM);
4531 out:
4532         return ret_val;
4533 }
4534
4535 /**
4536  * ixgbe_set_rxpba_generic - Initialize Rx packet buffer
4537  * @hw: pointer to hardware structure
4538  * @num_pb: number of packet buffers to allocate
4539  * @headroom: reserve n KB of headroom
4540  * @strategy: packet buffer allocation strategy
4541  **/
4542 void ixgbe_set_rxpba_generic(struct ixgbe_hw *hw, int num_pb, u32 headroom,
4543                              int strategy)
4544 {
4545         u32 pbsize = hw->mac.rx_pb_size;
4546         int i = 0;
4547         u32 rxpktsize, txpktsize, txpbthresh;
4548
4549         /* Reserve headroom */
4550         pbsize -= headroom;
4551
4552         if (!num_pb)
4553                 num_pb = 1;
4554
4555         /* Divide remaining packet buffer space amongst the number of packet
4556          * buffers requested using supplied strategy.
4557          */
4558         switch (strategy) {
4559         case PBA_STRATEGY_WEIGHTED:
4560                 /* ixgbe_dcb_pba_80_48 strategy weight first half of packet
4561                  * buffer with 5/8 of the packet buffer space.
4562                  */
4563                 rxpktsize = (pbsize * 5) / (num_pb * 4);
4564                 pbsize -= rxpktsize * (num_pb / 2);
4565                 rxpktsize <<= IXGBE_RXPBSIZE_SHIFT;
4566                 for (; i < (num_pb / 2); i++)
4567                         IXGBE_WRITE_REG(hw, IXGBE_RXPBSIZE(i), rxpktsize);
4568                 /* Fall through to configure remaining packet buffers */
4569         case PBA_STRATEGY_EQUAL:
4570                 rxpktsize = (pbsize / (num_pb - i)) << IXGBE_RXPBSIZE_SHIFT;
4571                 for (; i < num_pb; i++)
4572                         IXGBE_WRITE_REG(hw, IXGBE_RXPBSIZE(i), rxpktsize);
4573                 break;
4574         default:
4575                 break;
4576         }
4577
4578         /* Only support an equally distributed Tx packet buffer strategy. */
4579         txpktsize = IXGBE_TXPBSIZE_MAX / num_pb;
4580         txpbthresh = (txpktsize / 1024) - IXGBE_TXPKT_SIZE_MAX;
4581         for (i = 0; i < num_pb; i++) {
4582                 IXGBE_WRITE_REG(hw, IXGBE_TXPBSIZE(i), txpktsize);
4583                 IXGBE_WRITE_REG(hw, IXGBE_TXPBTHRESH(i), txpbthresh);
4584         }
4585
4586         /* Clear unused TCs, if any, to zero buffer size*/
4587         for (; i < IXGBE_MAX_PB; i++) {
4588                 IXGBE_WRITE_REG(hw, IXGBE_RXPBSIZE(i), 0);
4589                 IXGBE_WRITE_REG(hw, IXGBE_TXPBSIZE(i), 0);
4590                 IXGBE_WRITE_REG(hw, IXGBE_TXPBTHRESH(i), 0);
4591         }
4592 }
4593
4594 /**
4595  * ixgbe_clear_tx_pending - Clear pending TX work from the PCIe fifo
4596  * @hw: pointer to the hardware structure
4597  *
4598  * The 82599 and x540 MACs can experience issues if TX work is still pending
4599  * when a reset occurs.  This function prevents this by flushing the PCIe
4600  * buffers on the system.
4601  **/
4602 void ixgbe_clear_tx_pending(struct ixgbe_hw *hw)
4603 {
4604         u32 gcr_ext, hlreg0, i, poll;
4605         u16 value;
4606
4607         /*
4608          * If double reset is not requested then all transactions should
4609          * already be clear and as such there is no work to do
4610          */
4611         if (!(hw->mac.flags & IXGBE_FLAGS_DOUBLE_RESET_REQUIRED))
4612                 return;
4613
4614         /*
4615          * Set loopback enable to prevent any transmits from being sent
4616          * should the link come up.  This assumes that the RXCTRL.RXEN bit
4617          * has already been cleared.
4618          */
4619         hlreg0 = IXGBE_READ_REG(hw, IXGBE_HLREG0);
4620         IXGBE_WRITE_REG(hw, IXGBE_HLREG0, hlreg0 | IXGBE_HLREG0_LPBK);
4621
4622         /* Wait for a last completion before clearing buffers */
4623         IXGBE_WRITE_FLUSH(hw);
4624         msec_delay(3);
4625
4626         /*
4627          * Before proceeding, make sure that the PCIe block does not have
4628          * transactions pending.
4629          */
4630         poll = ixgbe_pcie_timeout_poll(hw);
4631         for (i = 0; i < poll; i++) {
4632                 usec_delay(100);
4633                 value = IXGBE_READ_PCIE_WORD(hw, IXGBE_PCI_DEVICE_STATUS);
4634                 if (IXGBE_REMOVED(hw->hw_addr))
4635                         goto out;
4636                 if (!(value & IXGBE_PCI_DEVICE_STATUS_TRANSACTION_PENDING))
4637                         goto out;
4638         }
4639
4640 out:
4641         /* initiate cleaning flow for buffers in the PCIe transaction layer */
4642         gcr_ext = IXGBE_READ_REG(hw, IXGBE_GCR_EXT);
4643         IXGBE_WRITE_REG(hw, IXGBE_GCR_EXT,
4644                         gcr_ext | IXGBE_GCR_EXT_BUFFERS_CLEAR);
4645
4646         /* Flush all writes and allow 20usec for all transactions to clear */
4647         IXGBE_WRITE_FLUSH(hw);
4648         usec_delay(20);
4649
4650         /* restore previous register values */
4651         IXGBE_WRITE_REG(hw, IXGBE_GCR_EXT, gcr_ext);
4652         IXGBE_WRITE_REG(hw, IXGBE_HLREG0, hlreg0);
4653 }
4654
4655
4656 /**
4657  * ixgbe_dcb_get_rtrup2tc_generic - read rtrup2tc reg
4658  * @hw: pointer to hardware structure
4659  * @map: pointer to u8 arr for returning map
4660  *
4661  * Read the rtrup2tc HW register and resolve its content into map
4662  **/
4663 void ixgbe_dcb_get_rtrup2tc_generic(struct ixgbe_hw *hw, u8 *map)
4664 {
4665         u32 reg, i;
4666
4667         reg = IXGBE_READ_REG(hw, IXGBE_RTRUP2TC);
4668         for (i = 0; i < IXGBE_DCB_MAX_USER_PRIORITY; i++)
4669                 map[i] = IXGBE_RTRUP2TC_UP_MASK &
4670                         (reg >> (i * IXGBE_RTRUP2TC_UP_SHIFT));
4671         return;
4672 }
4673
4674 void ixgbe_disable_rx_generic(struct ixgbe_hw *hw)
4675 {
4676         u32 pfdtxgswc;
4677         u32 rxctrl;
4678
4679         rxctrl = IXGBE_READ_REG(hw, IXGBE_RXCTRL);
4680         if (rxctrl & IXGBE_RXCTRL_RXEN) {
4681                 if (hw->mac.type != ixgbe_mac_82598EB) {
4682                         pfdtxgswc = IXGBE_READ_REG(hw, IXGBE_PFDTXGSWC);
4683                         if (pfdtxgswc & IXGBE_PFDTXGSWC_VT_LBEN) {
4684                                 pfdtxgswc &= ~IXGBE_PFDTXGSWC_VT_LBEN;
4685                                 IXGBE_WRITE_REG(hw, IXGBE_PFDTXGSWC, pfdtxgswc);
4686                                 hw->mac.set_lben = TRUE;
4687                         } else {
4688                                 hw->mac.set_lben = FALSE;
4689                         }
4690                 }
4691                 rxctrl &= ~IXGBE_RXCTRL_RXEN;
4692                 IXGBE_WRITE_REG(hw, IXGBE_RXCTRL, rxctrl);
4693         }
4694 }
4695
4696 void ixgbe_enable_rx_generic(struct ixgbe_hw *hw)
4697 {
4698         u32 pfdtxgswc;
4699         u32 rxctrl;
4700
4701         rxctrl = IXGBE_READ_REG(hw, IXGBE_RXCTRL);
4702         IXGBE_WRITE_REG(hw, IXGBE_RXCTRL, (rxctrl | IXGBE_RXCTRL_RXEN));
4703
4704         if (hw->mac.type != ixgbe_mac_82598EB) {
4705                 if (hw->mac.set_lben) {
4706                         pfdtxgswc = IXGBE_READ_REG(hw, IXGBE_PFDTXGSWC);
4707                         pfdtxgswc |= IXGBE_PFDTXGSWC_VT_LBEN;
4708                         IXGBE_WRITE_REG(hw, IXGBE_PFDTXGSWC, pfdtxgswc);
4709                         hw->mac.set_lben = FALSE;
4710                 }
4711         }
4712 }
4713
4714 /**
4715  * ixgbe_mng_present - returns TRUE when management capability is present
4716  * @hw: pointer to hardware structure
4717  */
4718 bool ixgbe_mng_present(struct ixgbe_hw *hw)
4719 {
4720         u32 fwsm;
4721
4722         if (hw->mac.type < ixgbe_mac_82599EB)
4723                 return FALSE;
4724
4725         fwsm = IXGBE_READ_REG(hw, IXGBE_FWSM_BY_MAC(hw));
4726         fwsm &= IXGBE_FWSM_MODE_MASK;
4727         return fwsm == IXGBE_FWSM_FW_MODE_PT;
4728 }
4729
4730 /**
4731  * ixgbe_mng_enabled - Is the manageability engine enabled?
4732  * @hw: pointer to hardware structure
4733  *
4734  * Returns TRUE if the manageability engine is enabled.
4735  **/
4736 bool ixgbe_mng_enabled(struct ixgbe_hw *hw)
4737 {
4738         u32 fwsm, manc, factps;
4739
4740         fwsm = IXGBE_READ_REG(hw, IXGBE_FWSM_BY_MAC(hw));
4741         if ((fwsm & IXGBE_FWSM_MODE_MASK) != IXGBE_FWSM_FW_MODE_PT)
4742                 return FALSE;
4743
4744         manc = IXGBE_READ_REG(hw, IXGBE_MANC);
4745         if (!(manc & IXGBE_MANC_RCV_TCO_EN))
4746                 return FALSE;
4747
4748         if (hw->mac.type <= ixgbe_mac_X540) {
4749                 factps = IXGBE_READ_REG(hw, IXGBE_FACTPS_BY_MAC(hw));
4750                 if (factps & IXGBE_FACTPS_MNGCG)
4751                         return FALSE;
4752         }
4753
4754         return TRUE;
4755 }
4756
4757 /**
4758  *  ixgbe_setup_mac_link_multispeed_fiber - Set MAC link speed
4759  *  @hw: pointer to hardware structure
4760  *  @speed: new link speed
4761  *  @autoneg_wait_to_complete: TRUE when waiting for completion is needed
4762  *
4763  *  Set the link speed in the MAC and/or PHY register and restarts link.
4764  **/
4765 s32 ixgbe_setup_mac_link_multispeed_fiber(struct ixgbe_hw *hw,
4766                                           ixgbe_link_speed speed,
4767                                           bool autoneg_wait_to_complete)
4768 {
4769         ixgbe_link_speed link_speed = IXGBE_LINK_SPEED_UNKNOWN;
4770         ixgbe_link_speed highest_link_speed = IXGBE_LINK_SPEED_UNKNOWN;
4771         s32 status = IXGBE_SUCCESS;
4772         u32 speedcnt = 0;
4773         u32 i = 0;
4774         bool autoneg, link_up = FALSE;
4775
4776         DEBUGFUNC("ixgbe_setup_mac_link_multispeed_fiber");
4777
4778         /* Mask off requested but non-supported speeds */
4779         status = ixgbe_get_link_capabilities(hw, &link_speed, &autoneg);
4780         if (status != IXGBE_SUCCESS)
4781                 return status;
4782
4783         speed &= link_speed;
4784
4785         /* Try each speed one by one, highest priority first.  We do this in
4786          * software because 10Gb fiber doesn't support speed autonegotiation.
4787          */
4788         if (speed & IXGBE_LINK_SPEED_10GB_FULL) {
4789                 speedcnt++;
4790                 highest_link_speed = IXGBE_LINK_SPEED_10GB_FULL;
4791
4792                 /* If we already have link at this speed, just jump out */
4793                 status = ixgbe_check_link(hw, &link_speed, &link_up, FALSE);
4794                 if (status != IXGBE_SUCCESS)
4795                         return status;
4796
4797                 if ((link_speed == IXGBE_LINK_SPEED_10GB_FULL) && link_up)
4798                         goto out;
4799
4800                 /* Set the module link speed */
4801                 switch (hw->phy.media_type) {
4802                 case ixgbe_media_type_fiber_fixed:
4803                 case ixgbe_media_type_fiber:
4804                         ixgbe_set_rate_select_speed(hw,
4805                                                     IXGBE_LINK_SPEED_10GB_FULL);
4806                         break;
4807                 case ixgbe_media_type_fiber_qsfp:
4808                         /* QSFP module automatically detects MAC link speed */
4809                         break;
4810                 default:
4811                         DEBUGOUT("Unexpected media type.\n");
4812                         break;
4813                 }
4814
4815                 /* Allow module to change analog characteristics (1G->10G) */
4816                 msec_delay(40);
4817
4818                 status = ixgbe_setup_mac_link(hw,
4819                                               IXGBE_LINK_SPEED_10GB_FULL,
4820                                               autoneg_wait_to_complete);
4821                 if (status != IXGBE_SUCCESS)
4822                         return status;
4823
4824                 /* Flap the Tx laser if it has not already been done */
4825                 ixgbe_flap_tx_laser(hw);
4826
4827                 /* Wait for the controller to acquire link.  Per IEEE 802.3ap,
4828                  * Section 73.10.2, we may have to wait up to 500ms if KR is
4829                  * attempted.  82599 uses the same timing for 10g SFI.
4830                  */
4831                 for (i = 0; i < 5; i++) {
4832                         /* Wait for the link partner to also set speed */
4833                         msec_delay(100);
4834
4835                         /* If we have link, just jump out */
4836                         status = ixgbe_check_link(hw, &link_speed,
4837                                                   &link_up, FALSE);
4838                         if (status != IXGBE_SUCCESS)
4839                                 return status;
4840
4841                         if (link_up)
4842                                 goto out;
4843                 }
4844         }
4845
4846         if (speed & IXGBE_LINK_SPEED_1GB_FULL) {
4847                 speedcnt++;
4848                 if (highest_link_speed == IXGBE_LINK_SPEED_UNKNOWN)
4849                         highest_link_speed = IXGBE_LINK_SPEED_1GB_FULL;
4850
4851                 /* If we already have link at this speed, just jump out */
4852                 status = ixgbe_check_link(hw, &link_speed, &link_up, FALSE);
4853                 if (status != IXGBE_SUCCESS)
4854                         return status;
4855
4856                 if ((link_speed == IXGBE_LINK_SPEED_1GB_FULL) && link_up)
4857                         goto out;
4858
4859                 /* Set the module link speed */
4860                 switch (hw->phy.media_type) {
4861                 case ixgbe_media_type_fiber_fixed:
4862                 case ixgbe_media_type_fiber:
4863                         ixgbe_set_rate_select_speed(hw,
4864                                                     IXGBE_LINK_SPEED_1GB_FULL);
4865                         break;
4866                 case ixgbe_media_type_fiber_qsfp:
4867                         /* QSFP module automatically detects link speed */
4868                         break;
4869                 default:
4870                         DEBUGOUT("Unexpected media type.\n");
4871                         break;
4872                 }
4873
4874                 /* Allow module to change analog characteristics (10G->1G) */
4875                 msec_delay(40);
4876
4877                 status = ixgbe_setup_mac_link(hw,
4878                                               IXGBE_LINK_SPEED_1GB_FULL,
4879                                               autoneg_wait_to_complete);
4880                 if (status != IXGBE_SUCCESS)
4881                         return status;
4882
4883                 /* Flap the Tx laser if it has not already been done */
4884                 ixgbe_flap_tx_laser(hw);
4885
4886                 /* Wait for the link partner to also set speed */
4887                 msec_delay(100);
4888
4889                 /* If we have link, just jump out */
4890                 status = ixgbe_check_link(hw, &link_speed, &link_up, FALSE);
4891                 if (status != IXGBE_SUCCESS)
4892                         return status;
4893
4894                 if (link_up)
4895                         goto out;
4896         }
4897
4898         /* We didn't get link.  Configure back to the highest speed we tried,
4899          * (if there was more than one).  We call ourselves back with just the
4900          * single highest speed that the user requested.
4901          */
4902         if (speedcnt > 1)
4903                 status = ixgbe_setup_mac_link_multispeed_fiber(hw,
4904                                                       highest_link_speed,
4905                                                       autoneg_wait_to_complete);
4906
4907 out:
4908         /* Set autoneg_advertised value based on input link speed */
4909         hw->phy.autoneg_advertised = 0;
4910
4911         if (speed & IXGBE_LINK_SPEED_10GB_FULL)
4912                 hw->phy.autoneg_advertised |= IXGBE_LINK_SPEED_10GB_FULL;
4913
4914         if (speed & IXGBE_LINK_SPEED_1GB_FULL)
4915                 hw->phy.autoneg_advertised |= IXGBE_LINK_SPEED_1GB_FULL;
4916
4917         return status;
4918 }
4919
4920 /**
4921  *  ixgbe_set_soft_rate_select_speed - Set module link speed
4922  *  @hw: pointer to hardware structure
4923  *  @speed: link speed to set
4924  *
4925  *  Set module link speed via the soft rate select.
4926  */
4927 void ixgbe_set_soft_rate_select_speed(struct ixgbe_hw *hw,
4928                                         ixgbe_link_speed speed)
4929 {
4930         s32 status;
4931         u8 rs, eeprom_data;
4932
4933         switch (speed) {
4934         case IXGBE_LINK_SPEED_10GB_FULL:
4935                 /* one bit mask same as setting on */
4936                 rs = IXGBE_SFF_SOFT_RS_SELECT_10G;
4937                 break;
4938         case IXGBE_LINK_SPEED_1GB_FULL:
4939                 rs = IXGBE_SFF_SOFT_RS_SELECT_1G;
4940                 break;
4941         default:
4942                 DEBUGOUT("Invalid fixed module speed\n");
4943                 return;
4944         }
4945
4946         /* Set RS0 */
4947         status = hw->phy.ops.read_i2c_byte(hw, IXGBE_SFF_SFF_8472_OSCB,
4948                                            IXGBE_I2C_EEPROM_DEV_ADDR2,
4949                                            &eeprom_data);
4950         if (status) {
4951                 DEBUGOUT("Failed to read Rx Rate Select RS0\n");
4952                 goto out;
4953         }
4954
4955         eeprom_data = (eeprom_data & ~IXGBE_SFF_SOFT_RS_SELECT_MASK) | rs;
4956
4957         status = hw->phy.ops.write_i2c_byte(hw, IXGBE_SFF_SFF_8472_OSCB,
4958                                             IXGBE_I2C_EEPROM_DEV_ADDR2,
4959                                             eeprom_data);
4960         if (status) {
4961                 DEBUGOUT("Failed to write Rx Rate Select RS0\n");
4962                 goto out;
4963         }
4964
4965         /* Set RS1 */
4966         status = hw->phy.ops.read_i2c_byte(hw, IXGBE_SFF_SFF_8472_ESCB,
4967                                            IXGBE_I2C_EEPROM_DEV_ADDR2,
4968                                            &eeprom_data);
4969         if (status) {
4970                 DEBUGOUT("Failed to read Rx Rate Select RS1\n");
4971                 goto out;
4972         }
4973
4974         eeprom_data = (eeprom_data & ~IXGBE_SFF_SOFT_RS_SELECT_MASK) | rs;
4975
4976         status = hw->phy.ops.write_i2c_byte(hw, IXGBE_SFF_SFF_8472_ESCB,
4977                                             IXGBE_I2C_EEPROM_DEV_ADDR2,
4978                                             eeprom_data);
4979         if (status) {
4980                 DEBUGOUT("Failed to write Rx Rate Select RS1\n");
4981                 goto out;
4982         }
4983 out:
4984         return;
4985 }