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