sys/dev/ixgbe/ixgbe_common.c

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