lib/librte_pmd_ixgbe/ixgbe/ixgbe_common.c

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