lib/librte_pmd_ixgbe/ixgbe/ixgbe_common.c

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