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                 ERROR_REPORT1(IXGBE_ERROR_POLLING,
2903                              "Auto-Negotiation did not complete or timed out");
2904                 goto out;
2905         }
2906
2907         pcs_anadv_reg = IXGBE_READ_REG(hw, IXGBE_PCS1GANA);
2908         pcs_lpab_reg = IXGBE_READ_REG(hw, IXGBE_PCS1GANLP);
2909
2910         ret_val =  ixgbe_negotiate_fc(hw, pcs_anadv_reg,
2911                                       pcs_lpab_reg, IXGBE_PCS1GANA_SYM_PAUSE,
2912                                       IXGBE_PCS1GANA_ASM_PAUSE,
2913                                       IXGBE_PCS1GANA_SYM_PAUSE,
2914                                       IXGBE_PCS1GANA_ASM_PAUSE);
2915
2916 out:
2917         return ret_val;
2918 }
2919
2920 /**
2921  *  ixgbe_fc_autoneg_backplane - Enable flow control IEEE clause 37
2922  *  @hw: pointer to hardware structure
2923  *
2924  *  Enable flow control according to IEEE clause 37.
2925  **/
2926 STATIC s32 ixgbe_fc_autoneg_backplane(struct ixgbe_hw *hw)
2927 {
2928         u32 links2, anlp1_reg, autoc_reg, links;
2929         s32 ret_val = IXGBE_ERR_FC_NOT_NEGOTIATED;
2930
2931         /*
2932          * On backplane, bail out if
2933          * - backplane autoneg was not completed, or if
2934          * - we are 82599 and link partner is not AN enabled
2935          */
2936         links = IXGBE_READ_REG(hw, IXGBE_LINKS);
2937         if ((links & IXGBE_LINKS_KX_AN_COMP) == 0) {
2938                 ERROR_REPORT1(IXGBE_ERROR_POLLING,
2939                              "Auto-Negotiation did not complete");
2940                 goto out;
2941         }
2942
2943         if (hw->mac.type == ixgbe_mac_82599EB) {
2944                 links2 = IXGBE_READ_REG(hw, IXGBE_LINKS2);
2945                 if ((links2 & IXGBE_LINKS2_AN_SUPPORTED) == 0) {
2946                         ERROR_REPORT1(IXGBE_ERROR_UNSUPPORTED,
2947                                      "Link partner is not AN enabled");
2948                         goto out;
2949                 }
2950         }
2951         /*
2952          * Read the 10g AN autoc and LP ability registers and resolve
2953          * local flow control settings accordingly
2954          */
2955         autoc_reg = IXGBE_READ_REG(hw, IXGBE_AUTOC);
2956         anlp1_reg = IXGBE_READ_REG(hw, IXGBE_ANLP1);
2957
2958         ret_val = ixgbe_negotiate_fc(hw, autoc_reg,
2959                 anlp1_reg, IXGBE_AUTOC_SYM_PAUSE, IXGBE_AUTOC_ASM_PAUSE,
2960                 IXGBE_ANLP1_SYM_PAUSE, IXGBE_ANLP1_ASM_PAUSE);
2961
2962 out:
2963         return ret_val;
2964 }
2965
2966 /**
2967  *  ixgbe_fc_autoneg_copper - Enable flow control IEEE clause 37
2968  *  @hw: pointer to hardware structure
2969  *
2970  *  Enable flow control according to IEEE clause 37.
2971  **/
2972 STATIC s32 ixgbe_fc_autoneg_copper(struct ixgbe_hw *hw)
2973 {
2974         u16 technology_ability_reg = 0;
2975         u16 lp_technology_ability_reg = 0;
2976
2977         hw->phy.ops.read_reg(hw, IXGBE_MDIO_AUTO_NEG_ADVT,
2978                              IXGBE_MDIO_AUTO_NEG_DEV_TYPE,
2979                              &technology_ability_reg);
2980         hw->phy.ops.read_reg(hw, IXGBE_MDIO_AUTO_NEG_LP,
2981                              IXGBE_MDIO_AUTO_NEG_DEV_TYPE,
2982                              &lp_technology_ability_reg);
2983
2984         return ixgbe_negotiate_fc(hw, (u32)technology_ability_reg,
2985                                   (u32)lp_technology_ability_reg,
2986                                   IXGBE_TAF_SYM_PAUSE, IXGBE_TAF_ASM_PAUSE,
2987                                   IXGBE_TAF_SYM_PAUSE, IXGBE_TAF_ASM_PAUSE);
2988 }
2989
2990 /**
2991  *  ixgbe_fc_autoneg - Configure flow control
2992  *  @hw: pointer to hardware structure
2993  *
2994  *  Compares our advertised flow control capabilities to those advertised by
2995  *  our link partner, and determines the proper flow control mode to use.
2996  **/
2997 void ixgbe_fc_autoneg(struct ixgbe_hw *hw)
2998 {
2999         s32 ret_val = IXGBE_ERR_FC_NOT_NEGOTIATED;
3000         ixgbe_link_speed speed;
3001         bool link_up;
3002
3003         DEBUGFUNC("ixgbe_fc_autoneg");
3004
3005         /*
3006          * AN should have completed when the cable was plugged in.
3007          * Look for reasons to bail out.  Bail out if:
3008          * - FC autoneg is disabled, or if
3009          * - link is not up.
3010          */
3011         if (hw->fc.disable_fc_autoneg) {
3012                 ERROR_REPORT1(IXGBE_ERROR_UNSUPPORTED,
3013                              "Flow control autoneg is disabled");
3014                 goto out;
3015         }
3016
3017         hw->mac.ops.check_link(hw, &speed, &link_up, false);
3018         if (!link_up) {
3019                 ERROR_REPORT1(IXGBE_ERROR_SOFTWARE, "The link is down");
3020                 goto out;
3021         }
3022
3023         switch (hw->phy.media_type) {
3024         /* Autoneg flow control on fiber adapters */
3025         case ixgbe_media_type_fiber_qsfp:
3026         case ixgbe_media_type_fiber:
3027                 if (speed == IXGBE_LINK_SPEED_1GB_FULL)
3028                         ret_val = ixgbe_fc_autoneg_fiber(hw);
3029                 break;
3030
3031         /* Autoneg flow control on backplane adapters */
3032         case ixgbe_media_type_backplane:
3033                 ret_val = ixgbe_fc_autoneg_backplane(hw);
3034                 break;
3035
3036         /* Autoneg flow control on copper adapters */
3037         case ixgbe_media_type_copper:
3038                 if (ixgbe_device_supports_autoneg_fc(hw))
3039                         ret_val = ixgbe_fc_autoneg_copper(hw);
3040                 break;
3041
3042         default:
3043                 break;
3044         }
3045
3046 out:
3047         if (ret_val == IXGBE_SUCCESS) {
3048                 hw->fc.fc_was_autonegged = true;
3049         } else {
3050                 hw->fc.fc_was_autonegged = false;
3051                 hw->fc.current_mode = hw->fc.requested_mode;
3052         }
3053 }
3054
3055 /*
3056  * ixgbe_pcie_timeout_poll - Return number of times to poll for completion
3057  * @hw: pointer to hardware structure
3058  *
3059  * System-wide timeout range is encoded in PCIe Device Control2 register.
3060  *
3061  * Add 10% to specified maximum and return the number of times to poll for
3062  * completion timeout, in units of 100 microsec.  Never return less than
3063  * 800 = 80 millisec.
3064  */
3065 STATIC u32 ixgbe_pcie_timeout_poll(struct ixgbe_hw *hw)
3066 {
3067         s16 devctl2;
3068         u32 pollcnt;
3069
3070         devctl2 = IXGBE_READ_PCIE_WORD(hw, IXGBE_PCI_DEVICE_CONTROL2);
3071         devctl2 &= IXGBE_PCIDEVCTRL2_TIMEO_MASK;
3072
3073         switch (devctl2) {
3074         case IXGBE_PCIDEVCTRL2_65_130ms:
3075                 pollcnt = 1300;         /* 130 millisec */
3076                 break;
3077         case IXGBE_PCIDEVCTRL2_260_520ms:
3078                 pollcnt = 5200;         /* 520 millisec */
3079                 break;
3080         case IXGBE_PCIDEVCTRL2_1_2s:
3081                 pollcnt = 20000;        /* 2 sec */
3082                 break;
3083         case IXGBE_PCIDEVCTRL2_4_8s:
3084                 pollcnt = 80000;        /* 8 sec */
3085                 break;
3086         case IXGBE_PCIDEVCTRL2_17_34s:
3087                 pollcnt = 34000;        /* 34 sec */
3088                 break;
3089         case IXGBE_PCIDEVCTRL2_50_100us:        /* 100 microsecs */
3090         case IXGBE_PCIDEVCTRL2_1_2ms:           /* 2 millisecs */
3091         case IXGBE_PCIDEVCTRL2_16_32ms:         /* 32 millisec */
3092         case IXGBE_PCIDEVCTRL2_16_32ms_def:     /* 32 millisec default */
3093         default:
3094                 pollcnt = 800;          /* 80 millisec minimum */
3095                 break;
3096         }
3097
3098         /* add 10% to spec maximum */
3099         return (pollcnt * 11) / 10;
3100 }
3101
3102 /**
3103  *  ixgbe_disable_pcie_master - Disable PCI-express master access
3104  *  @hw: pointer to hardware structure
3105  *
3106  *  Disables PCI-Express master access and verifies there are no pending
3107  *  requests. IXGBE_ERR_MASTER_REQUESTS_PENDING is returned if master disable
3108  *  bit hasn't caused the master requests to be disabled, else IXGBE_SUCCESS
3109  *  is returned signifying master requests disabled.
3110  **/
3111 s32 ixgbe_disable_pcie_master(struct ixgbe_hw *hw)
3112 {
3113         s32 status = IXGBE_SUCCESS;
3114         u32 i, poll;
3115         u16 value;
3116
3117         DEBUGFUNC("ixgbe_disable_pcie_master");
3118
3119         /* Always set this bit to ensure any future transactions are blocked */
3120         IXGBE_WRITE_REG(hw, IXGBE_CTRL, IXGBE_CTRL_GIO_DIS);
3121
3122         /* Exit if master requests are blocked */
3123         if (!(IXGBE_READ_REG(hw, IXGBE_STATUS) & IXGBE_STATUS_GIO) ||
3124             IXGBE_REMOVED(hw->hw_addr))
3125                 goto out;
3126
3127         /* Poll for master request bit to clear */
3128         for (i = 0; i < IXGBE_PCI_MASTER_DISABLE_TIMEOUT; i++) {
3129                 usec_delay(100);
3130                 if (!(IXGBE_READ_REG(hw, IXGBE_STATUS) & IXGBE_STATUS_GIO))
3131                         goto out;
3132         }
3133
3134         /*
3135          * Two consecutive resets are required via CTRL.RST per datasheet
3136          * 5.2.5.3.2 Master Disable.  We set a flag to inform the reset routine
3137          * of this need.  The first reset prevents new master requests from
3138          * being issued by our device.  We then must wait 1usec or more for any
3139          * remaining completions from the PCIe bus to trickle in, and then reset
3140          * again to clear out any effects they may have had on our device.
3141          */
3142         DEBUGOUT("GIO Master Disable bit didn't clear - requesting resets\n");
3143         hw->mac.flags |= IXGBE_FLAGS_DOUBLE_RESET_REQUIRED;
3144
3145         /*
3146          * Before proceeding, make sure that the PCIe block does not have
3147          * transactions pending.
3148          */
3149         poll = ixgbe_pcie_timeout_poll(hw);
3150         for (i = 0; i < poll; i++) {
3151                 usec_delay(100);
3152                 value = IXGBE_READ_PCIE_WORD(hw, IXGBE_PCI_DEVICE_STATUS);
3153                 if (IXGBE_REMOVED(hw->hw_addr))
3154                         goto out;
3155                 if (!(value & IXGBE_PCI_DEVICE_STATUS_TRANSACTION_PENDING))
3156                         goto out;
3157         }
3158
3159         ERROR_REPORT1(IXGBE_ERROR_POLLING,
3160                      "PCIe transaction pending bit also did not clear.\n");
3161         status = IXGBE_ERR_MASTER_REQUESTS_PENDING;
3162
3163 out:
3164         return status;
3165 }
3166
3167 /**
3168  *  ixgbe_acquire_swfw_sync - Acquire SWFW semaphore
3169  *  @hw: pointer to hardware structure
3170  *  @mask: Mask to specify which semaphore to acquire
3171  *
3172  *  Acquires the SWFW semaphore through the GSSR register for the specified
3173  *  function (CSR, PHY0, PHY1, EEPROM, Flash)
3174  **/
3175 s32 ixgbe_acquire_swfw_sync(struct ixgbe_hw *hw, u32 mask)
3176 {
3177         u32 gssr = 0;
3178         u32 swmask = mask;
3179         u32 fwmask = mask << 5;
3180         u32 timeout = 200;
3181         u32 i;
3182
3183         DEBUGFUNC("ixgbe_acquire_swfw_sync");
3184
3185         for (i = 0; i < timeout; i++) {
3186                 /*
3187                  * SW NVM semaphore bit is used for access to all
3188                  * SW_FW_SYNC bits (not just NVM)
3189                  */
3190                 if (ixgbe_get_eeprom_semaphore(hw))
3191                         return IXGBE_ERR_SWFW_SYNC;
3192
3193                 gssr = IXGBE_READ_REG(hw, IXGBE_GSSR);
3194                 if (!(gssr & (fwmask | swmask))) {
3195                         gssr |= swmask;
3196                         IXGBE_WRITE_REG(hw, IXGBE_GSSR, gssr);
3197                         ixgbe_release_eeprom_semaphore(hw);
3198                         return IXGBE_SUCCESS;
3199                 } else {
3200                         /* Resource is currently in use by FW or SW */
3201                         ixgbe_release_eeprom_semaphore(hw);
3202                         msec_delay(5);
3203                 }
3204         }
3205
3206         /* If time expired clear the bits holding the lock and retry */
3207         if (gssr & (fwmask | swmask))
3208                 ixgbe_release_swfw_sync(hw, gssr & (fwmask | swmask));
3209
3210         msec_delay(5);
3211         return IXGBE_ERR_SWFW_SYNC;
3212 }
3213
3214 /**
3215  *  ixgbe_release_swfw_sync - Release SWFW semaphore
3216  *  @hw: pointer to hardware structure
3217  *  @mask: Mask to specify which semaphore to release
3218  *
3219  *  Releases the SWFW semaphore through the GSSR register for the specified
3220  *  function (CSR, PHY0, PHY1, EEPROM, Flash)
3221  **/
3222 void ixgbe_release_swfw_sync(struct ixgbe_hw *hw, u32 mask)
3223 {
3224         u32 gssr;
3225         u32 swmask = mask;
3226
3227         DEBUGFUNC("ixgbe_release_swfw_sync");
3228
3229         ixgbe_get_eeprom_semaphore(hw);
3230
3231         gssr = IXGBE_READ_REG(hw, IXGBE_GSSR);
3232         gssr &= ~swmask;
3233         IXGBE_WRITE_REG(hw, IXGBE_GSSR, gssr);
3234
3235         ixgbe_release_eeprom_semaphore(hw);
3236 }
3237
3238 /**
3239  *  ixgbe_disable_sec_rx_path_generic - Stops the receive data path
3240  *  @hw: pointer to hardware structure
3241  *
3242  *  Stops the receive data path and waits for the HW to internally empty
3243  *  the Rx security block
3244  **/
3245 s32 ixgbe_disable_sec_rx_path_generic(struct ixgbe_hw *hw)
3246 {
3247 #define IXGBE_MAX_SECRX_POLL 40
3248
3249         int i;
3250         int secrxreg;
3251
3252         DEBUGFUNC("ixgbe_disable_sec_rx_path_generic");
3253
3254
3255         secrxreg = IXGBE_READ_REG(hw, IXGBE_SECRXCTRL);
3256         secrxreg |= IXGBE_SECRXCTRL_RX_DIS;
3257         IXGBE_WRITE_REG(hw, IXGBE_SECRXCTRL, secrxreg);
3258         for (i = 0; i < IXGBE_MAX_SECRX_POLL; i++) {
3259                 secrxreg = IXGBE_READ_REG(hw, IXGBE_SECRXSTAT);
3260                 if (secrxreg & IXGBE_SECRXSTAT_SECRX_RDY)
3261                         break;
3262                 else
3263                         /* Use interrupt-safe sleep just in case */
3264                         usec_delay(1000);
3265         }
3266
3267         /* For informational purposes only */
3268         if (i >= IXGBE_MAX_SECRX_POLL)
3269                 DEBUGOUT("Rx unit being enabled before security "
3270                          "path fully disabled.  Continuing with init.\n");
3271
3272         return IXGBE_SUCCESS;
3273 }
3274
3275 /**
3276  *  prot_autoc_read_generic - Hides MAC differences needed for AUTOC read
3277  *  @hw: pointer to hardware structure
3278  *  @reg_val: Value we read from AUTOC
3279  *
3280  *  The default case requires no protection so just to the register read.
3281  */
3282 s32 prot_autoc_read_generic(struct ixgbe_hw *hw, bool *locked, u32 *reg_val)
3283 {
3284         *locked = false;
3285         *reg_val = IXGBE_READ_REG(hw, IXGBE_AUTOC);
3286         return IXGBE_SUCCESS;
3287 }
3288
3289 /**
3290  * prot_autoc_write_generic - Hides MAC differences needed for AUTOC write
3291  * @hw: pointer to hardware structure
3292  * @reg_val: value to write to AUTOC
3293  * @locked: bool to indicate whether the SW/FW lock was already taken by
3294  *           previous read.
3295  *
3296  * The default case requires no protection so just to the register write.
3297  */
3298 s32 prot_autoc_write_generic(struct ixgbe_hw *hw, u32 reg_val, bool locked)
3299 {
3300         UNREFERENCED_1PARAMETER(locked);
3301
3302         IXGBE_WRITE_REG(hw, IXGBE_AUTOC, reg_val);
3303         return IXGBE_SUCCESS;
3304 }
3305
3306 /**
3307  *  ixgbe_enable_sec_rx_path_generic - Enables the receive data path
3308  *  @hw: pointer to hardware structure
3309  *
3310  *  Enables the receive data path.
3311  **/
3312 s32 ixgbe_enable_sec_rx_path_generic(struct ixgbe_hw *hw)
3313 {
3314         int secrxreg;
3315
3316         DEBUGFUNC("ixgbe_enable_sec_rx_path_generic");
3317
3318         secrxreg = IXGBE_READ_REG(hw, IXGBE_SECRXCTRL);
3319         secrxreg &= ~IXGBE_SECRXCTRL_RX_DIS;
3320         IXGBE_WRITE_REG(hw, IXGBE_SECRXCTRL, secrxreg);
3321         IXGBE_WRITE_FLUSH(hw);
3322
3323         return IXGBE_SUCCESS;
3324 }
3325
3326 /**
3327  *  ixgbe_enable_rx_dma_generic - Enable the Rx DMA unit
3328  *  @hw: pointer to hardware structure
3329  *  @regval: register value to write to RXCTRL
3330  *
3331  *  Enables the Rx DMA unit
3332  **/
3333 s32 ixgbe_enable_rx_dma_generic(struct ixgbe_hw *hw, u32 regval)
3334 {
3335         DEBUGFUNC("ixgbe_enable_rx_dma_generic");
3336
3337         if (regval & IXGBE_RXCTRL_RXEN)
3338                 ixgbe_enable_rx(hw);
3339         else
3340                 ixgbe_disable_rx(hw);
3341
3342         return IXGBE_SUCCESS;
3343 }
3344
3345 /**
3346  *  ixgbe_blink_led_start_generic - Blink LED based on index.
3347  *  @hw: pointer to hardware structure
3348  *  @index: led number to blink
3349  **/
3350 s32 ixgbe_blink_led_start_generic(struct ixgbe_hw *hw, u32 index)
3351 {
3352         ixgbe_link_speed speed = 0;
3353         bool link_up = 0;
3354         u32 autoc_reg = 0;
3355         u32 led_reg = IXGBE_READ_REG(hw, IXGBE_LEDCTL);
3356         s32 ret_val = IXGBE_SUCCESS;
3357         bool locked = false;
3358
3359         DEBUGFUNC("ixgbe_blink_led_start_generic");
3360
3361         /*
3362          * Link must be up to auto-blink the LEDs;
3363          * Force it if link is down.
3364          */
3365         hw->mac.ops.check_link(hw, &speed, &link_up, false);
3366
3367         if (!link_up) {
3368                 ret_val = hw->mac.ops.prot_autoc_read(hw, &locked, &autoc_reg);
3369                 if (ret_val != IXGBE_SUCCESS)
3370                         goto out;
3371
3372                 autoc_reg |= IXGBE_AUTOC_AN_RESTART;
3373                 autoc_reg |= IXGBE_AUTOC_FLU;
3374
3375                 ret_val = hw->mac.ops.prot_autoc_write(hw, autoc_reg, locked);
3376                 if (ret_val != IXGBE_SUCCESS)
3377                         goto out;
3378
3379                 IXGBE_WRITE_FLUSH(hw);
3380                 msec_delay(10);
3381         }
3382
3383         led_reg &= ~IXGBE_LED_MODE_MASK(index);
3384         led_reg |= IXGBE_LED_BLINK(index);
3385         IXGBE_WRITE_REG(hw, IXGBE_LEDCTL, led_reg);
3386         IXGBE_WRITE_FLUSH(hw);
3387
3388 out:
3389         return ret_val;
3390 }
3391
3392 /**
3393  *  ixgbe_blink_led_stop_generic - Stop blinking LED based on index.
3394  *  @hw: pointer to hardware structure
3395  *  @index: led number to stop blinking
3396  **/
3397 s32 ixgbe_blink_led_stop_generic(struct ixgbe_hw *hw, u32 index)
3398 {
3399         u32 autoc_reg = 0;
3400         u32 led_reg = IXGBE_READ_REG(hw, IXGBE_LEDCTL);
3401         s32 ret_val = IXGBE_SUCCESS;
3402         bool locked = false;
3403
3404         DEBUGFUNC("ixgbe_blink_led_stop_generic");
3405
3406         ret_val = hw->mac.ops.prot_autoc_read(hw, &locked, &autoc_reg);
3407         if (ret_val != IXGBE_SUCCESS)
3408                 goto out;
3409
3410         autoc_reg &= ~IXGBE_AUTOC_FLU;
3411         autoc_reg |= IXGBE_AUTOC_AN_RESTART;
3412
3413         ret_val = hw->mac.ops.prot_autoc_write(hw, autoc_reg, locked);
3414         if (ret_val != IXGBE_SUCCESS)
3415                 goto out;
3416
3417         led_reg &= ~IXGBE_LED_MODE_MASK(index);
3418         led_reg &= ~IXGBE_LED_BLINK(index);
3419         led_reg |= IXGBE_LED_LINK_ACTIVE << IXGBE_LED_MODE_SHIFT(index);
3420         IXGBE_WRITE_REG(hw, IXGBE_LEDCTL, led_reg);
3421         IXGBE_WRITE_FLUSH(hw);
3422
3423 out:
3424         return ret_val;
3425 }
3426
3427 /**
3428  *  ixgbe_get_san_mac_addr_offset - Get SAN MAC address offset from the EEPROM
3429  *  @hw: pointer to hardware structure
3430  *  @san_mac_offset: SAN MAC address offset
3431  *
3432  *  This function will read the EEPROM location for the SAN MAC address
3433  *  pointer, and returns the value at that location.  This is used in both
3434  *  get and set mac_addr routines.
3435  **/
3436 STATIC s32 ixgbe_get_san_mac_addr_offset(struct ixgbe_hw *hw,
3437                                          u16 *san_mac_offset)
3438 {
3439         s32 ret_val;
3440
3441         DEBUGFUNC("ixgbe_get_san_mac_addr_offset");
3442
3443         /*
3444          * First read the EEPROM pointer to see if the MAC addresses are
3445          * available.
3446          */
3447         ret_val = hw->eeprom.ops.read(hw, IXGBE_SAN_MAC_ADDR_PTR,
3448                                       san_mac_offset);
3449         if (ret_val) {
3450                 ERROR_REPORT2(IXGBE_ERROR_INVALID_STATE,
3451                               "eeprom at offset %d failed",
3452                               IXGBE_SAN_MAC_ADDR_PTR);
3453         }
3454
3455         return ret_val;
3456 }
3457
3458 /**
3459  *  ixgbe_get_san_mac_addr_generic - SAN MAC address retrieval from the EEPROM
3460  *  @hw: pointer to hardware structure
3461  *  @san_mac_addr: SAN MAC address
3462  *
3463  *  Reads the SAN MAC address from the EEPROM, if it's available.  This is
3464  *  per-port, so set_lan_id() must be called before reading the addresses.
3465  *  set_lan_id() is called by identify_sfp(), but this cannot be relied
3466  *  upon for non-SFP connections, so we must call it here.
3467  **/
3468 s32 ixgbe_get_san_mac_addr_generic(struct ixgbe_hw *hw, u8 *san_mac_addr)
3469 {
3470         u16 san_mac_data, san_mac_offset;
3471         u8 i;
3472         s32 ret_val;
3473
3474         DEBUGFUNC("ixgbe_get_san_mac_addr_generic");
3475
3476         /*
3477          * First read the EEPROM pointer to see if the MAC addresses are
3478          * available.  If they're not, no point in calling set_lan_id() here.
3479          */
3480         ret_val = ixgbe_get_san_mac_addr_offset(hw, &san_mac_offset);
3481         if (ret_val || san_mac_offset == 0 || san_mac_offset == 0xFFFF)
3482                 goto san_mac_addr_out;
3483
3484         /* make sure we know which port we need to program */
3485         hw->mac.ops.set_lan_id(hw);
3486         /* apply the port offset to the address offset */
3487         (hw->bus.func) ? (san_mac_offset += IXGBE_SAN_MAC_ADDR_PORT1_OFFSET) :
3488                          (san_mac_offset += IXGBE_SAN_MAC_ADDR_PORT0_OFFSET);
3489         for (i = 0; i < 3; i++) {
3490                 ret_val = hw->eeprom.ops.read(hw, san_mac_offset,
3491                                               &san_mac_data);
3492                 if (ret_val) {
3493                         ERROR_REPORT2(IXGBE_ERROR_INVALID_STATE,
3494                                       "eeprom read at offset %d failed",
3495                                       san_mac_offset);
3496                         goto san_mac_addr_out;
3497                 }
3498                 san_mac_addr[i * 2] = (u8)(san_mac_data);
3499                 san_mac_addr[i * 2 + 1] = (u8)(san_mac_data >> 8);
3500                 san_mac_offset++;
3501         }
3502         return IXGBE_SUCCESS;
3503
3504 san_mac_addr_out:
3505         /*
3506          * No addresses available in this EEPROM.  It's not an
3507          * error though, so just wipe the local address and return.
3508          */
3509         for (i = 0; i < 6; i++)
3510                 san_mac_addr[i] = 0xFF;
3511         return IXGBE_SUCCESS;
3512 }
3513
3514 /**
3515  *  ixgbe_set_san_mac_addr_generic - Write the SAN MAC address to the EEPROM
3516  *  @hw: pointer to hardware structure
3517  *  @san_mac_addr: SAN MAC address
3518  *
3519  *  Write a SAN MAC address to the EEPROM.
3520  **/
3521 s32 ixgbe_set_san_mac_addr_generic(struct ixgbe_hw *hw, u8 *san_mac_addr)
3522 {
3523         s32 ret_val;
3524         u16 san_mac_data, san_mac_offset;
3525         u8 i;
3526
3527         DEBUGFUNC("ixgbe_set_san_mac_addr_generic");
3528
3529         /* Look for SAN mac address pointer.  If not defined, return */
3530         ret_val = ixgbe_get_san_mac_addr_offset(hw, &san_mac_offset);
3531         if (ret_val || san_mac_offset == 0 || san_mac_offset == 0xFFFF)
3532                 return IXGBE_ERR_NO_SAN_ADDR_PTR;
3533
3534         /* Make sure we know which port we need to write */
3535         hw->mac.ops.set_lan_id(hw);
3536         /* Apply the port offset to the address offset */
3537         (hw->bus.func) ? (san_mac_offset += IXGBE_SAN_MAC_ADDR_PORT1_OFFSET) :
3538                          (san_mac_offset += IXGBE_SAN_MAC_ADDR_PORT0_OFFSET);
3539
3540         for (i = 0; i < 3; i++) {
3541                 san_mac_data = (u16)((u16)(san_mac_addr[i * 2 + 1]) << 8);
3542                 san_mac_data |= (u16)(san_mac_addr[i * 2]);
3543                 hw->eeprom.ops.write(hw, san_mac_offset, san_mac_data);
3544                 san_mac_offset++;
3545         }
3546
3547         return IXGBE_SUCCESS;
3548 }
3549
3550 /**
3551  *  ixgbe_get_pcie_msix_count_generic - Gets MSI-X vector count
3552  *  @hw: pointer to hardware structure
3553  *
3554  *  Read PCIe configuration space, and get the MSI-X vector count from
3555  *  the capabilities table.
3556  **/
3557 u16 ixgbe_get_pcie_msix_count_generic(struct ixgbe_hw *hw)
3558 {
3559         u16 msix_count = 1;
3560         u16 max_msix_count;
3561         u16 pcie_offset;
3562
3563         switch (hw->mac.type) {
3564         case ixgbe_mac_82598EB:
3565                 pcie_offset = IXGBE_PCIE_MSIX_82598_CAPS;
3566                 max_msix_count = IXGBE_MAX_MSIX_VECTORS_82598;
3567                 break;
3568         case ixgbe_mac_82599EB:
3569         case ixgbe_mac_X540:
3570         case ixgbe_mac_X550:
3571         case ixgbe_mac_X550EM_x:
3572                 pcie_offset = IXGBE_PCIE_MSIX_82599_CAPS;
3573                 max_msix_count = IXGBE_MAX_MSIX_VECTORS_82599;
3574                 break;
3575         default:
3576                 return msix_count;
3577         }
3578
3579         DEBUGFUNC("ixgbe_get_pcie_msix_count_generic");
3580         msix_count = IXGBE_READ_PCIE_WORD(hw, pcie_offset);
3581         if (IXGBE_REMOVED(hw->hw_addr))
3582                 msix_count = 0;
3583         msix_count &= IXGBE_PCIE_MSIX_TBL_SZ_MASK;
3584
3585         /* MSI-X count is zero-based in HW */
3586         msix_count++;
3587
3588         if (msix_count > max_msix_count)
3589                 msix_count = max_msix_count;
3590
3591         return msix_count;
3592 }
3593
3594 /**
3595  *  ixgbe_insert_mac_addr_generic - Find a RAR for this mac address
3596  *  @hw: pointer to hardware structure
3597  *  @addr: Address to put into receive address register
3598  *  @vmdq: VMDq pool to assign
3599  *
3600  *  Puts an ethernet address into a receive address register, or
3601  *  finds the rar that it is aleady in; adds to the pool list
3602  **/
3603 s32 ixgbe_insert_mac_addr_generic(struct ixgbe_hw *hw, u8 *addr, u32 vmdq)
3604 {
3605         static const u32 NO_EMPTY_RAR_FOUND = 0xFFFFFFFF;
3606         u32 first_empty_rar = NO_EMPTY_RAR_FOUND;
3607         u32 rar;
3608         u32 rar_low, rar_high;
3609         u32 addr_low, addr_high;
3610
3611         DEBUGFUNC("ixgbe_insert_mac_addr_generic");
3612
3613         /* swap bytes for HW little endian */
3614         addr_low  = addr[0] | (addr[1] << 8)
3615                             | (addr[2] << 16)
3616                             | (addr[3] << 24);
3617         addr_high = addr[4] | (addr[5] << 8);
3618
3619         /*
3620          * Either find the mac_id in rar or find the first empty space.
3621          * rar_highwater points to just after the highest currently used
3622          * rar in order to shorten the search.  It grows when we add a new
3623          * rar to the top.
3624          */
3625         for (rar = 0; rar < hw->mac.rar_highwater; rar++) {
3626                 rar_high = IXGBE_READ_REG(hw, IXGBE_RAH(rar));
3627
3628                 if (((IXGBE_RAH_AV & rar_high) == 0)
3629                     && first_empty_rar == NO_EMPTY_RAR_FOUND) {
3630                         first_empty_rar = rar;
3631                 } else if ((rar_high & 0xFFFF) == addr_high) {
3632                         rar_low = IXGBE_READ_REG(hw, IXGBE_RAL(rar));
3633                         if (rar_low == addr_low)
3634                                 break;    /* found it already in the rars */
3635                 }
3636         }
3637
3638         if (rar < hw->mac.rar_highwater) {
3639                 /* already there so just add to the pool bits */
3640                 ixgbe_set_vmdq(hw, rar, vmdq);
3641         } else if (first_empty_rar != NO_EMPTY_RAR_FOUND) {
3642                 /* stick it into first empty RAR slot we found */
3643                 rar = first_empty_rar;
3644                 ixgbe_set_rar(hw, rar, addr, vmdq, IXGBE_RAH_AV);
3645         } else if (rar == hw->mac.rar_highwater) {
3646                 /* add it to the top of the list and inc the highwater mark */
3647                 ixgbe_set_rar(hw, rar, addr, vmdq, IXGBE_RAH_AV);
3648                 hw->mac.rar_highwater++;
3649         } else if (rar >= hw->mac.num_rar_entries) {
3650                 return IXGBE_ERR_INVALID_MAC_ADDR;
3651         }
3652
3653         /*
3654          * If we found rar[0], make sure the default pool bit (we use pool 0)
3655          * remains cleared to be sure default pool packets will get delivered
3656          */
3657         if (rar == 0)
3658                 ixgbe_clear_vmdq(hw, rar, 0);
3659
3660         return rar;
3661 }
3662
3663 /**
3664  *  ixgbe_clear_vmdq_generic - Disassociate a VMDq pool index from a rx address
3665  *  @hw: pointer to hardware struct
3666  *  @rar: receive address register index to disassociate
3667  *  @vmdq: VMDq pool index to remove from the rar
3668  **/
3669 s32 ixgbe_clear_vmdq_generic(struct ixgbe_hw *hw, u32 rar, u32 vmdq)
3670 {
3671         u32 mpsar_lo, mpsar_hi;
3672         u32 rar_entries = hw->mac.num_rar_entries;
3673
3674         DEBUGFUNC("ixgbe_clear_vmdq_generic");
3675
3676         /* Make sure we are using a valid rar index range */
3677         if (rar >= rar_entries) {
3678                 ERROR_REPORT2(IXGBE_ERROR_ARGUMENT,
3679                              "RAR index %d is out of range.\n", rar);
3680                 return IXGBE_ERR_INVALID_ARGUMENT;
3681         }
3682
3683         mpsar_lo = IXGBE_READ_REG(hw, IXGBE_MPSAR_LO(rar));
3684         mpsar_hi = IXGBE_READ_REG(hw, IXGBE_MPSAR_HI(rar));
3685
3686         if (IXGBE_REMOVED(hw->hw_addr))
3687                 goto done;
3688
3689         if (!mpsar_lo && !mpsar_hi)
3690                 goto done;
3691
3692         if (vmdq == IXGBE_CLEAR_VMDQ_ALL) {
3693                 if (mpsar_lo) {
3694                         IXGBE_WRITE_REG(hw, IXGBE_MPSAR_LO(rar), 0);
3695                         mpsar_lo = 0;
3696                 }
3697                 if (mpsar_hi) {
3698                         IXGBE_WRITE_REG(hw, IXGBE_MPSAR_HI(rar), 0);
3699                         mpsar_hi = 0;
3700                 }
3701         } else if (vmdq < 32) {
3702                 mpsar_lo &= ~(1 << vmdq);
3703                 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_LO(rar), mpsar_lo);
3704         } else {
3705                 mpsar_hi &= ~(1 << (vmdq - 32));
3706                 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_HI(rar), mpsar_hi);
3707         }
3708
3709         /* was that the last pool using this rar? */
3710         if (mpsar_lo == 0 && mpsar_hi == 0 && rar != 0)
3711                 hw->mac.ops.clear_rar(hw, rar);
3712 done:
3713         return IXGBE_SUCCESS;
3714 }
3715
3716 /**
3717  *  ixgbe_set_vmdq_generic - Associate a VMDq pool index with a rx address
3718  *  @hw: pointer to hardware struct
3719  *  @rar: receive address register index to associate with a VMDq index
3720  *  @vmdq: VMDq pool index
3721  **/
3722 s32 ixgbe_set_vmdq_generic(struct ixgbe_hw *hw, u32 rar, u32 vmdq)
3723 {
3724         u32 mpsar;
3725         u32 rar_entries = hw->mac.num_rar_entries;
3726
3727         DEBUGFUNC("ixgbe_set_vmdq_generic");
3728
3729         /* Make sure we are using a valid rar index range */
3730         if (rar >= rar_entries) {
3731                 ERROR_REPORT2(IXGBE_ERROR_ARGUMENT,
3732                              "RAR index %d is out of range.\n", rar);
3733                 return IXGBE_ERR_INVALID_ARGUMENT;
3734         }
3735
3736         if (vmdq < 32) {
3737                 mpsar = IXGBE_READ_REG(hw, IXGBE_MPSAR_LO(rar));
3738                 mpsar |= 1 << vmdq;
3739                 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_LO(rar), mpsar);
3740         } else {
3741                 mpsar = IXGBE_READ_REG(hw, IXGBE_MPSAR_HI(rar));
3742                 mpsar |= 1 << (vmdq - 32);
3743                 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_HI(rar), mpsar);
3744         }
3745         return IXGBE_SUCCESS;
3746 }
3747
3748 /**
3749  *  This function should only be involved in the IOV mode.
3750  *  In IOV mode, Default pool is next pool after the number of
3751  *  VFs advertized and not 0.
3752  *  MPSAR table needs to be updated for SAN_MAC RAR [hw->mac.san_mac_rar_index]
3753  *
3754  *  ixgbe_set_vmdq_san_mac - Associate default VMDq pool index with a rx address
3755  *  @hw: pointer to hardware struct
3756  *  @vmdq: VMDq pool index
3757  **/
3758 s32 ixgbe_set_vmdq_san_mac_generic(struct ixgbe_hw *hw, u32 vmdq)
3759 {
3760         u32 rar = hw->mac.san_mac_rar_index;
3761
3762         DEBUGFUNC("ixgbe_set_vmdq_san_mac");
3763
3764         if (vmdq < 32) {
3765                 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_LO(rar), 1 << vmdq);
3766                 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_HI(rar), 0);
3767         } else {
3768                 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_LO(rar), 0);
3769                 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_HI(rar), 1 << (vmdq - 32));
3770         }
3771
3772         return IXGBE_SUCCESS;
3773 }
3774
3775 /**
3776  *  ixgbe_init_uta_tables_generic - Initialize the Unicast Table Array
3777  *  @hw: pointer to hardware structure
3778  **/
3779 s32 ixgbe_init_uta_tables_generic(struct ixgbe_hw *hw)
3780 {
3781         int i;
3782
3783         DEBUGFUNC("ixgbe_init_uta_tables_generic");
3784         DEBUGOUT(" Clearing UTA\n");
3785
3786         for (i = 0; i < 128; i++)
3787                 IXGBE_WRITE_REG(hw, IXGBE_UTA(i), 0);
3788
3789         return IXGBE_SUCCESS;
3790 }
3791
3792 /**
3793  *  ixgbe_find_vlvf_slot - find the vlanid or the first empty slot
3794  *  @hw: pointer to hardware structure
3795  *  @vlan: VLAN id to write to VLAN filter
3796  *
3797  *  return the VLVF index where this VLAN id should be placed
3798  *
3799  **/
3800 s32 ixgbe_find_vlvf_slot(struct ixgbe_hw *hw, u32 vlan)
3801 {
3802         u32 bits = 0;
3803         u32 first_empty_slot = 0;
3804         s32 regindex;
3805
3806         /* short cut the special case */
3807         if (vlan == 0)
3808                 return 0;
3809
3810         /*
3811           * Search for the vlan id in the VLVF entries. Save off the first empty
3812           * slot found along the way
3813           */
3814         for (regindex = 1; regindex < IXGBE_VLVF_ENTRIES; regindex++) {
3815                 bits = IXGBE_READ_REG(hw, IXGBE_VLVF(regindex));
3816                 if (!bits && !(first_empty_slot))
3817                         first_empty_slot = regindex;
3818                 else if ((bits & 0x0FFF) == vlan)
3819                         break;
3820         }
3821
3822         /*
3823           * If regindex is less than IXGBE_VLVF_ENTRIES, then we found the vlan
3824           * in the VLVF. Else use the first empty VLVF register for this
3825           * vlan id.
3826           */
3827         if (regindex >= IXGBE_VLVF_ENTRIES) {
3828                 if (first_empty_slot)
3829                         regindex = first_empty_slot;
3830                 else {
3831                         ERROR_REPORT1(IXGBE_ERROR_SOFTWARE,
3832                                      "No space in VLVF.\n");
3833                         regindex = IXGBE_ERR_NO_SPACE;
3834                 }
3835         }
3836
3837         return regindex;
3838 }
3839
3840 /**
3841  *  ixgbe_set_vfta_generic - Set VLAN filter table
3842  *  @hw: pointer to hardware structure
3843  *  @vlan: VLAN id to write to VLAN filter
3844  *  @vind: VMDq output index that maps queue to VLAN id in VFVFB
3845  *  @vlan_on: boolean flag to turn on/off VLAN in VFVF
3846  *
3847  *  Turn on/off specified VLAN in the VLAN filter table.
3848  **/
3849 s32 ixgbe_set_vfta_generic(struct ixgbe_hw *hw, u32 vlan, u32 vind,
3850                            bool vlan_on)
3851 {
3852         s32 regindex;
3853         u32 bitindex;
3854         u32 vfta;
3855         u32 targetbit;
3856         s32 ret_val = IXGBE_SUCCESS;
3857         bool vfta_changed = false;
3858
3859         DEBUGFUNC("ixgbe_set_vfta_generic");
3860
3861         if (vlan > 4095)
3862                 return IXGBE_ERR_PARAM;
3863
3864         /*
3865          * this is a 2 part operation - first the VFTA, then the
3866          * VLVF and VLVFB if VT Mode is set
3867          * We don't write the VFTA until we know the VLVF part succeeded.
3868          */
3869
3870         /* Part 1
3871          * The VFTA is a bitstring made up of 128 32-bit registers
3872          * that enable the particular VLAN id, much like the MTA:
3873          *    bits[11-5]: which register
3874          *    bits[4-0]:  which bit in the register
3875          */
3876         regindex = (vlan >> 5) & 0x7F;
3877         bitindex = vlan & 0x1F;
3878         targetbit = (1 << bitindex);
3879         vfta = IXGBE_READ_REG(hw, IXGBE_VFTA(regindex));
3880
3881         if (vlan_on) {
3882                 if (!(vfta & targetbit)) {
3883                         vfta |= targetbit;
3884                         vfta_changed = true;
3885                 }
3886         } else {
3887                 if ((vfta & targetbit)) {
3888                         vfta &= ~targetbit;
3889                         vfta_changed = true;
3890                 }
3891         }
3892
3893         /* Part 2
3894          * Call ixgbe_set_vlvf_generic to set VLVFB and VLVF
3895          */
3896         ret_val = ixgbe_set_vlvf_generic(hw, vlan, vind, vlan_on,
3897                                          &vfta_changed);
3898         if (ret_val != IXGBE_SUCCESS)
3899                 return ret_val;
3900
3901         if (vfta_changed)
3902                 IXGBE_WRITE_REG(hw, IXGBE_VFTA(regindex), vfta);
3903
3904         return IXGBE_SUCCESS;
3905 }
3906
3907 /**
3908  *  ixgbe_set_vlvf_generic - Set VLAN Pool Filter
3909  *  @hw: pointer to hardware structure
3910  *  @vlan: VLAN id to write to VLAN filter
3911  *  @vind: VMDq output index that maps queue to VLAN id in VFVFB
3912  *  @vlan_on: boolean flag to turn on/off VLAN in VFVF
3913  *  @vfta_changed: pointer to boolean flag which indicates whether VFTA
3914  *                 should be changed
3915  *
3916  *  Turn on/off specified bit in VLVF table.
3917  **/
3918 s32 ixgbe_set_vlvf_generic(struct ixgbe_hw *hw, u32 vlan, u32 vind,
3919                             bool vlan_on, bool *vfta_changed)
3920 {
3921         u32 vt;
3922
3923         DEBUGFUNC("ixgbe_set_vlvf_generic");
3924
3925         if (vlan > 4095)
3926                 return IXGBE_ERR_PARAM;
3927
3928         /* If VT Mode is set
3929          *   Either vlan_on
3930          *     make sure the vlan is in VLVF
3931          *     set the vind bit in the matching VLVFB
3932          *   Or !vlan_on
3933          *     clear the pool bit and possibly the vind
3934          */
3935         vt = IXGBE_READ_REG(hw, IXGBE_VT_CTL);
3936         if (vt & IXGBE_VT_CTL_VT_ENABLE) {
3937                 s32 vlvf_index;
3938                 u32 bits;
3939
3940                 vlvf_index = ixgbe_find_vlvf_slot(hw, vlan);
3941                 if (vlvf_index < 0)
3942                         return vlvf_index;
3943
3944                 if (vlan_on) {
3945                         /* set the pool bit */
3946                         if (vind < 32) {
3947                                 bits = IXGBE_READ_REG(hw,
3948                                                 IXGBE_VLVFB(vlvf_index * 2));
3949                                 bits |= (1 << vind);
3950                                 IXGBE_WRITE_REG(hw,
3951                                                 IXGBE_VLVFB(vlvf_index * 2),
3952                                                 bits);
3953                         } else {
3954                                 bits = IXGBE_READ_REG(hw,
3955                                         IXGBE_VLVFB((vlvf_index * 2) + 1));
3956                                 bits |= (1 << (vind - 32));
3957                                 IXGBE_WRITE_REG(hw,
3958                                         IXGBE_VLVFB((vlvf_index * 2) + 1),
3959                                         bits);
3960                         }
3961                 } else {
3962                         /* clear the pool bit */
3963                         if (vind < 32) {
3964                                 bits = IXGBE_READ_REG(hw,
3965                                                 IXGBE_VLVFB(vlvf_index * 2));
3966                                 bits &= ~(1 << vind);
3967                                 IXGBE_WRITE_REG(hw,
3968                                                 IXGBE_VLVFB(vlvf_index * 2),
3969                                                 bits);
3970                                 bits |= IXGBE_READ_REG(hw,
3971                                         IXGBE_VLVFB((vlvf_index * 2) + 1));
3972                         } else {
3973                                 bits = IXGBE_READ_REG(hw,
3974                                         IXGBE_VLVFB((vlvf_index * 2) + 1));
3975                                 bits &= ~(1 << (vind - 32));
3976                                 IXGBE_WRITE_REG(hw,
3977                                         IXGBE_VLVFB((vlvf_index * 2) + 1),
3978                                         bits);
3979                                 bits |= IXGBE_READ_REG(hw,
3980                                                 IXGBE_VLVFB(vlvf_index * 2));
3981                         }
3982                 }
3983
3984                 /*
3985                  * If there are still bits set in the VLVFB registers
3986                  * for the VLAN ID indicated we need to see if the
3987                  * caller is requesting that we clear the VFTA entry bit.
3988                  * If the caller has requested that we clear the VFTA
3989                  * entry bit but there are still pools/VFs using this VLAN
3990                  * ID entry then ignore the request.  We're not worried
3991                  * about the case where we're turning the VFTA VLAN ID
3992                  * entry bit on, only when requested to turn it off as
3993                  * there may be multiple pools and/or VFs using the
3994                  * VLAN ID entry.  In that case we cannot clear the
3995                  * VFTA bit until all pools/VFs using that VLAN ID have also
3996                  * been cleared.  This will be indicated by "bits" being
3997                  * zero.
3998                  */
3999                 if (bits) {
4000                         IXGBE_WRITE_REG(hw, IXGBE_VLVF(vlvf_index),
4001                                         (IXGBE_VLVF_VIEN | vlan));
4002                         if ((!vlan_on) && (vfta_changed != NULL)) {
4003                                 /* someone wants to clear the vfta entry
4004                                  * but some pools/VFs are still using it.
4005                                  * Ignore it. */
4006                                 *vfta_changed = false;
4007                         }
4008                 } else
4009                         IXGBE_WRITE_REG(hw, IXGBE_VLVF(vlvf_index), 0);
4010         }
4011
4012         return IXGBE_SUCCESS;
4013 }
4014
4015 /**
4016  *  ixgbe_clear_vfta_generic - Clear VLAN filter table
4017  *  @hw: pointer to hardware structure
4018  *
4019  *  Clears the VLAN filer table, and the VMDq index associated with the filter
4020  **/
4021 s32 ixgbe_clear_vfta_generic(struct ixgbe_hw *hw)
4022 {
4023         u32 offset;
4024
4025         DEBUGFUNC("ixgbe_clear_vfta_generic");
4026
4027         for (offset = 0; offset < hw->mac.vft_size; offset++)
4028                 IXGBE_WRITE_REG(hw, IXGBE_VFTA(offset), 0);
4029
4030         for (offset = 0; offset < IXGBE_VLVF_ENTRIES; offset++) {
4031                 IXGBE_WRITE_REG(hw, IXGBE_VLVF(offset), 0);
4032                 IXGBE_WRITE_REG(hw, IXGBE_VLVFB(offset * 2), 0);
4033                 IXGBE_WRITE_REG(hw, IXGBE_VLVFB((offset * 2) + 1), 0);
4034         }
4035
4036         return IXGBE_SUCCESS;
4037 }
4038
4039 /**
4040  *  ixgbe_check_mac_link_generic - Determine link and speed status
4041  *  @hw: pointer to hardware structure
4042  *  @speed: pointer to link speed
4043  *  @link_up: true when link is up
4044  *  @link_up_wait_to_complete: bool used to wait for link up or not
4045  *
4046  *  Reads the links register to determine if link is up and the current speed
4047  **/
4048 s32 ixgbe_check_mac_link_generic(struct ixgbe_hw *hw, ixgbe_link_speed *speed,
4049                                  bool *link_up, bool link_up_wait_to_complete)
4050 {
4051         u32 links_reg, links_orig;
4052         u32 i;
4053
4054         DEBUGFUNC("ixgbe_check_mac_link_generic");
4055
4056         /* clear the old state */
4057         links_orig = IXGBE_READ_REG(hw, IXGBE_LINKS);
4058
4059         links_reg = IXGBE_READ_REG(hw, IXGBE_LINKS);
4060
4061         if (links_orig != links_reg) {
4062                 DEBUGOUT2("LINKS changed from %08X to %08X\n",
4063                           links_orig, links_reg);
4064         }
4065
4066         if (link_up_wait_to_complete) {
4067                 for (i = 0; i < IXGBE_LINK_UP_TIME; i++) {
4068                         if (links_reg & IXGBE_LINKS_UP) {
4069                                 *link_up = true;
4070                                 break;
4071                         } else {
4072                                 *link_up = false;
4073                         }
4074                         msec_delay(100);
4075                         links_reg = IXGBE_READ_REG(hw, IXGBE_LINKS);
4076                 }
4077         } else {
4078                 if (links_reg & IXGBE_LINKS_UP)
4079                         *link_up = true;
4080                 else
4081                         *link_up = false;
4082         }
4083
4084         if ((links_reg & IXGBE_LINKS_SPEED_82599) ==
4085             IXGBE_LINKS_SPEED_10G_82599) {
4086                 *speed = IXGBE_LINK_SPEED_10GB_FULL;
4087                 if (hw->mac.type > ixgbe_mac_X550) {
4088                         if (links_reg & IXGBE_LINKS_SPEED_NON_STD)
4089                                 *speed = IXGBE_LINK_SPEED_2_5GB_FULL;
4090                 }
4091         }
4092         else if ((links_reg & IXGBE_LINKS_SPEED_82599) ==
4093                  IXGBE_LINKS_SPEED_1G_82599)
4094                 *speed = IXGBE_LINK_SPEED_1GB_FULL;
4095         else if ((links_reg & IXGBE_LINKS_SPEED_82599) ==
4096                  IXGBE_LINKS_SPEED_100_82599)
4097                 *speed = IXGBE_LINK_SPEED_100_FULL;
4098         else
4099                 *speed = IXGBE_LINK_SPEED_UNKNOWN;
4100
4101         return IXGBE_SUCCESS;
4102 }
4103
4104 /**
4105  *  ixgbe_get_wwn_prefix_generic - Get alternative WWNN/WWPN prefix from
4106  *  the EEPROM
4107  *  @hw: pointer to hardware structure
4108  *  @wwnn_prefix: the alternative WWNN prefix
4109  *  @wwpn_prefix: the alternative WWPN prefix
4110  *
4111  *  This function will read the EEPROM from the alternative SAN MAC address
4112  *  block to check the support for the alternative WWNN/WWPN prefix support.
4113  **/
4114 s32 ixgbe_get_wwn_prefix_generic(struct ixgbe_hw *hw, u16 *wwnn_prefix,
4115                                  u16 *wwpn_prefix)
4116 {
4117         u16 offset, caps;
4118         u16 alt_san_mac_blk_offset;
4119
4120         DEBUGFUNC("ixgbe_get_wwn_prefix_generic");
4121
4122         /* clear output first */
4123         *wwnn_prefix = 0xFFFF;
4124         *wwpn_prefix = 0xFFFF;
4125
4126         /* check if alternative SAN MAC is supported */
4127         offset = IXGBE_ALT_SAN_MAC_ADDR_BLK_PTR;
4128         if (hw->eeprom.ops.read(hw, offset, &alt_san_mac_blk_offset))
4129                 goto wwn_prefix_err;
4130
4131         if ((alt_san_mac_blk_offset == 0) ||
4132             (alt_san_mac_blk_offset == 0xFFFF))
4133                 goto wwn_prefix_out;
4134
4135         /* check capability in alternative san mac address block */
4136         offset = alt_san_mac_blk_offset + IXGBE_ALT_SAN_MAC_ADDR_CAPS_OFFSET;
4137         if (hw->eeprom.ops.read(hw, offset, &caps))
4138                 goto wwn_prefix_err;
4139         if (!(caps & IXGBE_ALT_SAN_MAC_ADDR_CAPS_ALTWWN))
4140                 goto wwn_prefix_out;
4141
4142         /* get the corresponding prefix for WWNN/WWPN */
4143         offset = alt_san_mac_blk_offset + IXGBE_ALT_SAN_MAC_ADDR_WWNN_OFFSET;
4144         if (hw->eeprom.ops.read(hw, offset, wwnn_prefix)) {
4145                 ERROR_REPORT2(IXGBE_ERROR_INVALID_STATE,
4146                               "eeprom read at offset %d failed", offset);
4147         }
4148
4149         offset = alt_san_mac_blk_offset + IXGBE_ALT_SAN_MAC_ADDR_WWPN_OFFSET;
4150         if (hw->eeprom.ops.read(hw, offset, wwpn_prefix))
4151                 goto wwn_prefix_err;
4152
4153 wwn_prefix_out:
4154         return IXGBE_SUCCESS;
4155
4156 wwn_prefix_err:
4157         ERROR_REPORT2(IXGBE_ERROR_INVALID_STATE,
4158                       "eeprom read at offset %d failed", offset);
4159         return IXGBE_SUCCESS;
4160 }
4161
4162 /**
4163  *  ixgbe_get_fcoe_boot_status_generic - Get FCOE boot status from EEPROM
4164  *  @hw: pointer to hardware structure
4165  *  @bs: the fcoe boot status
4166  *
4167  *  This function will read the FCOE boot status from the iSCSI FCOE block
4168  **/
4169 s32 ixgbe_get_fcoe_boot_status_generic(struct ixgbe_hw *hw, u16 *bs)
4170 {
4171         u16 offset, caps, flags;
4172         s32 status;
4173
4174         DEBUGFUNC("ixgbe_get_fcoe_boot_status_generic");
4175
4176         /* clear output first */
4177         *bs = ixgbe_fcoe_bootstatus_unavailable;
4178
4179         /* check if FCOE IBA block is present */
4180         offset = IXGBE_FCOE_IBA_CAPS_BLK_PTR;
4181         status = hw->eeprom.ops.read(hw, offset, &caps);
4182         if (status != IXGBE_SUCCESS)
4183                 goto out;
4184
4185         if (!(caps & IXGBE_FCOE_IBA_CAPS_FCOE))
4186                 goto out;
4187
4188         /* check if iSCSI FCOE block is populated */
4189         status = hw->eeprom.ops.read(hw, IXGBE_ISCSI_FCOE_BLK_PTR, &offset);
4190         if (status != IXGBE_SUCCESS)
4191                 goto out;
4192
4193         if ((offset == 0) || (offset == 0xFFFF))
4194                 goto out;
4195
4196         /* read fcoe flags in iSCSI FCOE block */
4197         offset = offset + IXGBE_ISCSI_FCOE_FLAGS_OFFSET;
4198         status = hw->eeprom.ops.read(hw, offset, &flags);
4199         if (status != IXGBE_SUCCESS)
4200                 goto out;
4201
4202         if (flags & IXGBE_ISCSI_FCOE_FLAGS_ENABLE)
4203                 *bs = ixgbe_fcoe_bootstatus_enabled;
4204         else
4205                 *bs = ixgbe_fcoe_bootstatus_disabled;
4206
4207 out:
4208         return status;
4209 }
4210
4211 /**
4212  *  ixgbe_set_mac_anti_spoofing - Enable/Disable MAC anti-spoofing
4213  *  @hw: pointer to hardware structure
4214  *  @enable: enable or disable switch for anti-spoofing
4215  *  @pf: Physical Function pool - do not enable anti-spoofing for the PF
4216  *
4217  **/
4218 void ixgbe_set_mac_anti_spoofing(struct ixgbe_hw *hw, bool enable, int pf)
4219 {
4220         int j;
4221         int pf_target_reg = pf >> 3;
4222         int pf_target_shift = pf % 8;
4223         u32 pfvfspoof = 0;
4224
4225         if (hw->mac.type == ixgbe_mac_82598EB)
4226                 return;
4227
4228         if (enable)
4229                 pfvfspoof = IXGBE_SPOOF_MACAS_MASK;
4230
4231         /*
4232          * PFVFSPOOF register array is size 8 with 8 bits assigned to
4233          * MAC anti-spoof enables in each register array element.
4234          */
4235         for (j = 0; j < pf_target_reg; j++)
4236                 IXGBE_WRITE_REG(hw, IXGBE_PFVFSPOOF(j), pfvfspoof);
4237
4238         /*
4239          * The PF should be allowed to spoof so that it can support
4240          * emulation mode NICs.  Do not set the bits assigned to the PF
4241          */
4242         pfvfspoof &= (1 << pf_target_shift) - 1;
4243         IXGBE_WRITE_REG(hw, IXGBE_PFVFSPOOF(j), pfvfspoof);
4244
4245         /*
4246          * Remaining pools belong to the PF so they do not need to have
4247          * anti-spoofing enabled.
4248          */
4249         for (j++; j < IXGBE_PFVFSPOOF_REG_COUNT; j++)
4250                 IXGBE_WRITE_REG(hw, IXGBE_PFVFSPOOF(j), 0);
4251 }
4252
4253 /**
4254  *  ixgbe_set_vlan_anti_spoofing - Enable/Disable VLAN anti-spoofing
4255  *  @hw: pointer to hardware structure
4256  *  @enable: enable or disable switch for VLAN anti-spoofing
4257  *  @vf: Virtual Function pool - VF Pool to set for VLAN anti-spoofing
4258  *
4259  **/
4260 void ixgbe_set_vlan_anti_spoofing(struct ixgbe_hw *hw, bool enable, int vf)
4261 {
4262         int vf_target_reg = vf >> 3;
4263         int vf_target_shift = vf % 8 + IXGBE_SPOOF_VLANAS_SHIFT;
4264         u32 pfvfspoof;
4265
4266         if (hw->mac.type == ixgbe_mac_82598EB)
4267                 return;
4268
4269         pfvfspoof = IXGBE_READ_REG(hw, IXGBE_PFVFSPOOF(vf_target_reg));
4270         if (enable)
4271                 pfvfspoof |= (1 << vf_target_shift);
4272         else
4273                 pfvfspoof &= ~(1 << vf_target_shift);
4274         IXGBE_WRITE_REG(hw, IXGBE_PFVFSPOOF(vf_target_reg), pfvfspoof);
4275 }
4276
4277 /**
4278  *  ixgbe_get_device_caps_generic - Get additional device capabilities
4279  *  @hw: pointer to hardware structure
4280  *  @device_caps: the EEPROM word with the extra device capabilities
4281  *
4282  *  This function will read the EEPROM location for the device capabilities,
4283  *  and return the word through device_caps.
4284  **/
4285 s32 ixgbe_get_device_caps_generic(struct ixgbe_hw *hw, u16 *device_caps)
4286 {
4287         DEBUGFUNC("ixgbe_get_device_caps_generic");
4288
4289         hw->eeprom.ops.read(hw, IXGBE_DEVICE_CAPS, device_caps);
4290
4291         return IXGBE_SUCCESS;
4292 }
4293
4294 /**
4295  *  ixgbe_enable_relaxed_ordering_gen2 - Enable relaxed ordering
4296  *  @hw: pointer to hardware structure
4297  *
4298  **/
4299 void ixgbe_enable_relaxed_ordering_gen2(struct ixgbe_hw *hw)
4300 {
4301         u32 regval;
4302         u32 i;
4303
4304         DEBUGFUNC("ixgbe_enable_relaxed_ordering_gen2");
4305
4306         /* Enable relaxed ordering */
4307         for (i = 0; i < hw->mac.max_tx_queues; i++) {
4308                 regval = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL_82599(i));
4309                 regval |= IXGBE_DCA_TXCTRL_DESC_WRO_EN;
4310                 IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL_82599(i), regval);
4311         }
4312
4313         for (i = 0; i < hw->mac.max_rx_queues; i++) {
4314                 regval = IXGBE_READ_REG(hw, IXGBE_DCA_RXCTRL(i));
4315                 regval |= IXGBE_DCA_RXCTRL_DATA_WRO_EN |
4316                           IXGBE_DCA_RXCTRL_HEAD_WRO_EN;
4317                 IXGBE_WRITE_REG(hw, IXGBE_DCA_RXCTRL(i), regval);
4318         }
4319
4320 }
4321
4322 /**
4323  *  ixgbe_calculate_checksum - Calculate checksum for buffer
4324  *  @buffer: pointer to EEPROM
4325  *  @length: size of EEPROM to calculate a checksum for
4326  *  Calculates the checksum for some buffer on a specified length.  The
4327  *  checksum calculated is returned.
4328  **/
4329 u8 ixgbe_calculate_checksum(u8 *buffer, u32 length)
4330 {
4331         u32 i;
4332         u8 sum = 0;
4333
4334         DEBUGFUNC("ixgbe_calculate_checksum");
4335
4336         if (!buffer)
4337                 return 0;
4338
4339         for (i = 0; i < length; i++)
4340                 sum += buffer[i];
4341
4342         return (u8) (0 - sum);
4343 }
4344
4345 /**
4346  *  ixgbe_host_interface_command - Issue command to manageability block
4347  *  @hw: pointer to the HW structure
4348  *  @buffer: contains the command to write and where the return status will
4349  *   be placed
4350  *  @length: length of buffer, must be multiple of 4 bytes
4351  *  @return_data: read and return data from the buffer (true) or not (false)
4352  *   Needed because FW structures are big endian and decoding of
4353  *   these fields can be 8 bit or 16 bit based on command. Decoding
4354  *   is not easily understood without making a table of commands.
4355  *   So we will leave this up to the caller to read back the data
4356  *   in these cases.
4357  *
4358  *  Communicates with the manageability block.  On success return IXGBE_SUCCESS
4359  *  else return IXGBE_ERR_HOST_INTERFACE_COMMAND.
4360  **/
4361 s32 ixgbe_host_interface_command(struct ixgbe_hw *hw, u32 *buffer,
4362                                  u32 length, bool return_data)
4363 {
4364         u32 hicr, i, bi, fwsts;
4365         u32 hdr_size = sizeof(struct ixgbe_hic_hdr);
4366         u16 buf_len;
4367         u8 dword_len;
4368
4369         DEBUGFUNC("ixgbe_host_interface_command");
4370
4371         if (length == 0 || length > IXGBE_HI_MAX_BLOCK_BYTE_LENGTH) {
4372                 DEBUGOUT1("Buffer length failure buffersize=%d.\n", length);
4373                 return IXGBE_ERR_HOST_INTERFACE_COMMAND;
4374         }
4375         /* Set bit 9 of FWSTS clearing FW reset indication */
4376         fwsts = IXGBE_READ_REG(hw, IXGBE_FWSTS);
4377         IXGBE_WRITE_REG(hw, IXGBE_FWSTS, fwsts | IXGBE_FWSTS_FWRI);
4378
4379         /* Check that the host interface is enabled. */
4380         hicr = IXGBE_READ_REG(hw, IXGBE_HICR);
4381         if ((hicr & IXGBE_HICR_EN) == 0) {
4382                 DEBUGOUT("IXGBE_HOST_EN bit disabled.\n");
4383                 return IXGBE_ERR_HOST_INTERFACE_COMMAND;
4384         }
4385
4386         /* Calculate length in DWORDs. We must be DWORD aligned */
4387         if ((length % (sizeof(u32))) != 0) {
4388                 DEBUGOUT("Buffer length failure, not aligned to dword");
4389                 return IXGBE_ERR_INVALID_ARGUMENT;
4390         }
4391
4392         dword_len = length >> 2;
4393
4394         /* The device driver writes the relevant command block
4395          * into the ram area.
4396          */
4397         for (i = 0; i < dword_len; i++)
4398                 IXGBE_WRITE_REG_ARRAY(hw, IXGBE_FLEX_MNG,
4399                                       i, IXGBE_CPU_TO_LE32(buffer[i]));
4400
4401         /* Setting this bit tells the ARC that a new command is pending. */
4402         IXGBE_WRITE_REG(hw, IXGBE_HICR, hicr | IXGBE_HICR_C);
4403
4404         for (i = 0; i < IXGBE_HI_COMMAND_TIMEOUT; i++) {
4405                 hicr = IXGBE_READ_REG(hw, IXGBE_HICR);
4406                 if (!(hicr & IXGBE_HICR_C))
4407                         break;
4408                 msec_delay(1);
4409         }
4410
4411         /* Check command completion */
4412         if (i == IXGBE_HI_COMMAND_TIMEOUT ||
4413             !(IXGBE_READ_REG(hw, IXGBE_HICR) & IXGBE_HICR_SV)) {
4414                 ERROR_REPORT1(IXGBE_ERROR_CAUTION,
4415                              "Command has failed with no status valid.\n");
4416                 return IXGBE_ERR_HOST_INTERFACE_COMMAND;
4417         }
4418
4419         if (!return_data)
4420                 return 0;
4421
4422         /* Calculate length in DWORDs */
4423         dword_len = hdr_size >> 2;
4424
4425         /* first pull in the header so we know the buffer length */
4426         for (bi = 0; bi < dword_len; bi++) {
4427                 buffer[bi] = IXGBE_READ_REG_ARRAY(hw, IXGBE_FLEX_MNG, bi);
4428                 IXGBE_LE32_TO_CPUS(&buffer[bi]);
4429         }
4430
4431         /* If there is any thing in data position pull it in */
4432         buf_len = ((struct ixgbe_hic_hdr *)buffer)->buf_len;
4433         if (buf_len == 0)
4434                 return 0;
4435
4436         if (length < buf_len + hdr_size) {
4437                 DEBUGOUT("Buffer not large enough for reply message.\n");
4438                 return IXGBE_ERR_HOST_INTERFACE_COMMAND;
4439         }
4440
4441         /* Calculate length in DWORDs, add 3 for odd lengths */
4442         dword_len = (buf_len + 3) >> 2;
4443
4444         /* Pull in the rest of the buffer (bi is where we left off) */
4445         for (; bi <= dword_len; bi++) {
4446                 buffer[bi] = IXGBE_READ_REG_ARRAY(hw, IXGBE_FLEX_MNG, bi);
4447                 IXGBE_LE32_TO_CPUS(&buffer[bi]);
4448         }
4449
4450         return 0;
4451 }
4452
4453 /**
4454  *  ixgbe_set_fw_drv_ver_generic - Sends driver version to firmware
4455  *  @hw: pointer to the HW structure
4456  *  @maj: driver version major number
4457  *  @min: driver version minor number
4458  *  @build: driver version build number
4459  *  @sub: driver version sub build number
4460  *
4461  *  Sends driver version number to firmware through the manageability
4462  *  block.  On success return IXGBE_SUCCESS
4463  *  else returns IXGBE_ERR_SWFW_SYNC when encountering an error acquiring
4464  *  semaphore or IXGBE_ERR_HOST_INTERFACE_COMMAND when command fails.
4465  **/
4466 s32 ixgbe_set_fw_drv_ver_generic(struct ixgbe_hw *hw, u8 maj, u8 min,
4467                                  u8 build, u8 sub)
4468 {
4469         struct ixgbe_hic_drv_info fw_cmd;
4470         int i;
4471         s32 ret_val = IXGBE_SUCCESS;
4472
4473         DEBUGFUNC("ixgbe_set_fw_drv_ver_generic");
4474
4475         if (hw->mac.ops.acquire_swfw_sync(hw, IXGBE_GSSR_SW_MNG_SM)
4476             != IXGBE_SUCCESS) {
4477                 ret_val = IXGBE_ERR_SWFW_SYNC;
4478                 goto out;
4479         }
4480
4481         fw_cmd.hdr.cmd = FW_CEM_CMD_DRIVER_INFO;
4482         fw_cmd.hdr.buf_len = FW_CEM_CMD_DRIVER_INFO_LEN;
4483         fw_cmd.hdr.cmd_or_resp.cmd_resv = FW_CEM_CMD_RESERVED;
4484         fw_cmd.port_num = (u8)hw->bus.func;
4485         fw_cmd.ver_maj = maj;
4486         fw_cmd.ver_min = min;
4487         fw_cmd.ver_build = build;
4488         fw_cmd.ver_sub = sub;
4489         fw_cmd.hdr.checksum = 0;
4490         fw_cmd.hdr.checksum = ixgbe_calculate_checksum((u8 *)&fw_cmd,
4491                                 (FW_CEM_HDR_LEN + fw_cmd.hdr.buf_len));
4492         fw_cmd.pad = 0;
4493         fw_cmd.pad2 = 0;
4494
4495         for (i = 0; i <= FW_CEM_MAX_RETRIES; i++) {
4496                 ret_val = ixgbe_host_interface_command(hw, (u32 *)&fw_cmd,
4497                                                        sizeof(fw_cmd), true);
4498                 if (ret_val != IXGBE_SUCCESS)
4499                         continue;
4500
4501                 if (fw_cmd.hdr.cmd_or_resp.ret_status ==
4502                     FW_CEM_RESP_STATUS_SUCCESS)
4503                         ret_val = IXGBE_SUCCESS;
4504                 else
4505                         ret_val = IXGBE_ERR_HOST_INTERFACE_COMMAND;
4506
4507                 break;
4508         }
4509
4510         hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_SW_MNG_SM);
4511 out:
4512         return ret_val;
4513 }
4514
4515 /**
4516  * ixgbe_set_rxpba_generic - Initialize Rx packet buffer
4517  * @hw: pointer to hardware structure
4518  * @num_pb: number of packet buffers to allocate
4519  * @headroom: reserve n KB of headroom
4520  * @strategy: packet buffer allocation strategy
4521  **/
4522 void ixgbe_set_rxpba_generic(struct ixgbe_hw *hw, int num_pb, u32 headroom,
4523                              int strategy)
4524 {
4525         u32 pbsize = hw->mac.rx_pb_size;
4526         int i = 0;
4527         u32 rxpktsize, txpktsize, txpbthresh;
4528
4529         /* Reserve headroom */
4530         pbsize -= headroom;
4531
4532         if (!num_pb)
4533                 num_pb = 1;
4534
4535         /* Divide remaining packet buffer space amongst the number of packet
4536          * buffers requested using supplied strategy.
4537          */
4538         switch (strategy) {
4539         case PBA_STRATEGY_WEIGHTED:
4540                 /* ixgbe_dcb_pba_80_48 strategy weight first half of packet
4541                  * buffer with 5/8 of the packet buffer space.
4542                  */
4543                 rxpktsize = (pbsize * 5) / (num_pb * 4);
4544                 pbsize -= rxpktsize * (num_pb / 2);
4545                 rxpktsize <<= IXGBE_RXPBSIZE_SHIFT;
4546                 for (; i < (num_pb / 2); i++)
4547                         IXGBE_WRITE_REG(hw, IXGBE_RXPBSIZE(i), rxpktsize);
4548                 /* Fall through to configure remaining packet buffers */
4549         case PBA_STRATEGY_EQUAL:
4550                 rxpktsize = (pbsize / (num_pb - i)) << IXGBE_RXPBSIZE_SHIFT;
4551                 for (; i < num_pb; i++)
4552                         IXGBE_WRITE_REG(hw, IXGBE_RXPBSIZE(i), rxpktsize);
4553                 break;
4554         default:
4555                 break;
4556         }
4557
4558         /* Only support an equally distributed Tx packet buffer strategy. */
4559         txpktsize = IXGBE_TXPBSIZE_MAX / num_pb;
4560         txpbthresh = (txpktsize / 1024) - IXGBE_TXPKT_SIZE_MAX;
4561         for (i = 0; i < num_pb; i++) {
4562                 IXGBE_WRITE_REG(hw, IXGBE_TXPBSIZE(i), txpktsize);
4563                 IXGBE_WRITE_REG(hw, IXGBE_TXPBTHRESH(i), txpbthresh);
4564         }
4565
4566         /* Clear unused TCs, if any, to zero buffer size*/
4567         for (; i < IXGBE_MAX_PB; i++) {
4568                 IXGBE_WRITE_REG(hw, IXGBE_RXPBSIZE(i), 0);
4569                 IXGBE_WRITE_REG(hw, IXGBE_TXPBSIZE(i), 0);
4570                 IXGBE_WRITE_REG(hw, IXGBE_TXPBTHRESH(i), 0);
4571         }
4572 }
4573
4574 /**
4575  * ixgbe_clear_tx_pending - Clear pending TX work from the PCIe fifo
4576  * @hw: pointer to the hardware structure
4577  *
4578  * The 82599 and x540 MACs can experience issues if TX work is still pending
4579  * when a reset occurs.  This function prevents this by flushing the PCIe
4580  * buffers on the system.
4581  **/
4582 void ixgbe_clear_tx_pending(struct ixgbe_hw *hw)
4583 {
4584         u32 gcr_ext, hlreg0;
4585
4586         /*
4587          * If double reset is not requested then all transactions should
4588          * already be clear and as such there is no work to do
4589          */
4590         if (!(hw->mac.flags & IXGBE_FLAGS_DOUBLE_RESET_REQUIRED))
4591                 return;
4592
4593         /*
4594          * Set loopback enable to prevent any transmits from being sent
4595          * should the link come up.  This assumes that the RXCTRL.RXEN bit
4596          * has already been cleared.
4597          */
4598         hlreg0 = IXGBE_READ_REG(hw, IXGBE_HLREG0);
4599         IXGBE_WRITE_REG(hw, IXGBE_HLREG0, hlreg0 | IXGBE_HLREG0_LPBK);
4600
4601         /* initiate cleaning flow for buffers in the PCIe transaction layer */
4602         gcr_ext = IXGBE_READ_REG(hw, IXGBE_GCR_EXT);
4603         IXGBE_WRITE_REG(hw, IXGBE_GCR_EXT,
4604                         gcr_ext | IXGBE_GCR_EXT_BUFFERS_CLEAR);
4605
4606         /* Flush all writes and allow 20usec for all transactions to clear */
4607         IXGBE_WRITE_FLUSH(hw);
4608         usec_delay(20);
4609
4610         /* restore previous register values */
4611         IXGBE_WRITE_REG(hw, IXGBE_GCR_EXT, gcr_ext);
4612         IXGBE_WRITE_REG(hw, IXGBE_HLREG0, hlreg0);
4613 }
4614
4615 STATIC const u8 ixgbe_emc_temp_data[4] = {
4616         IXGBE_EMC_INTERNAL_DATA,
4617         IXGBE_EMC_DIODE1_DATA,
4618         IXGBE_EMC_DIODE2_DATA,
4619         IXGBE_EMC_DIODE3_DATA
4620 };
4621 STATIC const u8 ixgbe_emc_therm_limit[4] = {
4622         IXGBE_EMC_INTERNAL_THERM_LIMIT,
4623         IXGBE_EMC_DIODE1_THERM_LIMIT,
4624         IXGBE_EMC_DIODE2_THERM_LIMIT,
4625         IXGBE_EMC_DIODE3_THERM_LIMIT
4626 };
4627
4628 /**
4629  *  ixgbe_get_thermal_sensor_data - Gathers thermal sensor data
4630  *  @hw: pointer to hardware structure
4631  *  @data: pointer to the thermal sensor data structure
4632  *
4633  *  Returns the thermal sensor data structure
4634  **/
4635 s32 ixgbe_get_thermal_sensor_data_generic(struct ixgbe_hw *hw)
4636 {
4637         s32 status = IXGBE_SUCCESS;
4638         u16 ets_offset;
4639         u16 ets_cfg;
4640         u16 ets_sensor;
4641         u8  num_sensors;
4642         u8  sensor_index;
4643         u8  sensor_location;
4644         u8  i;
4645         struct ixgbe_thermal_sensor_data *data = &hw->mac.thermal_sensor_data;
4646
4647         DEBUGFUNC("ixgbe_get_thermal_sensor_data_generic");
4648
4649         /* Only support thermal sensors attached to 82599 physical port 0 */
4650         if ((hw->mac.type != ixgbe_mac_82599EB) ||
4651             (IXGBE_READ_REG(hw, IXGBE_STATUS) & IXGBE_STATUS_LAN_ID_1)) {
4652                 status = IXGBE_NOT_IMPLEMENTED;
4653                 goto out;
4654         }
4655
4656         status = hw->eeprom.ops.read(hw, IXGBE_ETS_CFG, &ets_offset);
4657         if (status)
4658                 goto out;
4659
4660         if ((ets_offset == 0x0000) || (ets_offset == 0xFFFF)) {
4661                 status = IXGBE_NOT_IMPLEMENTED;
4662                 goto out;
4663         }
4664
4665         status = hw->eeprom.ops.read(hw, ets_offset, &ets_cfg);
4666         if (status)
4667                 goto out;
4668
4669         if (((ets_cfg & IXGBE_ETS_TYPE_MASK) >> IXGBE_ETS_TYPE_SHIFT)
4670                 != IXGBE_ETS_TYPE_EMC) {
4671                 status = IXGBE_NOT_IMPLEMENTED;
4672                 goto out;
4673         }
4674
4675         num_sensors = (ets_cfg & IXGBE_ETS_NUM_SENSORS_MASK);
4676         if (num_sensors > IXGBE_MAX_SENSORS)
4677                 num_sensors = IXGBE_MAX_SENSORS;
4678
4679         for (i = 0; i < num_sensors; i++) {
4680                 status = hw->eeprom.ops.read(hw, (ets_offset + 1 + i),
4681                                              &ets_sensor);
4682                 if (status)
4683                         goto out;
4684
4685                 sensor_index = ((ets_sensor & IXGBE_ETS_DATA_INDEX_MASK) >>
4686                                 IXGBE_ETS_DATA_INDEX_SHIFT);
4687                 sensor_location = ((ets_sensor & IXGBE_ETS_DATA_LOC_MASK) >>
4688                                    IXGBE_ETS_DATA_LOC_SHIFT);
4689
4690                 if (sensor_location != 0) {
4691                         status = hw->phy.ops.read_i2c_byte(hw,
4692                                         ixgbe_emc_temp_data[sensor_index],
4693                                         IXGBE_I2C_THERMAL_SENSOR_ADDR,
4694                                         &data->sensor[i].temp);
4695                         if (status)
4696                                 goto out;
4697                 }
4698         }
4699 out:
4700         return status;
4701 }
4702
4703 /**
4704  *  ixgbe_init_thermal_sensor_thresh_generic - Inits thermal sensor thresholds
4705  *  @hw: pointer to hardware structure
4706  *
4707  *  Inits the thermal sensor thresholds according to the NVM map
4708  *  and save off the threshold and location values into mac.thermal_sensor_data
4709  **/
4710 s32 ixgbe_init_thermal_sensor_thresh_generic(struct ixgbe_hw *hw)
4711 {
4712         s32 status = IXGBE_SUCCESS;
4713         u16 offset;
4714         u16 ets_offset;
4715         u16 ets_cfg;
4716         u16 ets_sensor;
4717         u8  low_thresh_delta;
4718         u8  num_sensors;
4719         u8  sensor_index;
4720         u8  sensor_location;
4721         u8  therm_limit;
4722         u8  i;
4723         struct ixgbe_thermal_sensor_data *data = &hw->mac.thermal_sensor_data;
4724
4725         DEBUGFUNC("ixgbe_init_thermal_sensor_thresh_generic");
4726
4727         memset(data, 0, sizeof(struct ixgbe_thermal_sensor_data));
4728
4729         /* Only support thermal sensors attached to 82599 physical port 0 */
4730         if ((hw->mac.type != ixgbe_mac_82599EB) ||
4731             (IXGBE_READ_REG(hw, IXGBE_STATUS) & IXGBE_STATUS_LAN_ID_1))
4732                 return IXGBE_NOT_IMPLEMENTED;
4733
4734         offset = IXGBE_ETS_CFG;
4735         if (hw->eeprom.ops.read(hw, offset, &ets_offset))
4736                 goto eeprom_err;
4737         if ((ets_offset == 0x0000) || (ets_offset == 0xFFFF))
4738                 return IXGBE_NOT_IMPLEMENTED;
4739
4740         offset = ets_offset;
4741         if (hw->eeprom.ops.read(hw, offset, &ets_cfg))
4742                 goto eeprom_err;
4743         if (((ets_cfg & IXGBE_ETS_TYPE_MASK) >> IXGBE_ETS_TYPE_SHIFT)
4744                 != IXGBE_ETS_TYPE_EMC)
4745                 return IXGBE_NOT_IMPLEMENTED;
4746
4747         low_thresh_delta = ((ets_cfg & IXGBE_ETS_LTHRES_DELTA_MASK) >>
4748                              IXGBE_ETS_LTHRES_DELTA_SHIFT);
4749         num_sensors = (ets_cfg & IXGBE_ETS_NUM_SENSORS_MASK);
4750
4751         for (i = 0; i < num_sensors; i++) {
4752                 offset = ets_offset + 1 + i;
4753                 if (hw->eeprom.ops.read(hw, offset, &ets_sensor)) {
4754                         ERROR_REPORT2(IXGBE_ERROR_INVALID_STATE,
4755                                       "eeprom read at offset %d failed",
4756                                       offset);
4757                         continue;
4758                 }
4759                 sensor_index = ((ets_sensor & IXGBE_ETS_DATA_INDEX_MASK) >>
4760                                 IXGBE_ETS_DATA_INDEX_SHIFT);
4761                 sensor_location = ((ets_sensor & IXGBE_ETS_DATA_LOC_MASK) >>
4762                                    IXGBE_ETS_DATA_LOC_SHIFT);
4763                 therm_limit = ets_sensor & IXGBE_ETS_DATA_HTHRESH_MASK;
4764
4765                 hw->phy.ops.write_i2c_byte(hw,
4766                         ixgbe_emc_therm_limit[sensor_index],
4767                         IXGBE_I2C_THERMAL_SENSOR_ADDR, therm_limit);
4768
4769                 if ((i < IXGBE_MAX_SENSORS) && (sensor_location != 0)) {
4770                         data->sensor[i].location = sensor_location;
4771                         data->sensor[i].caution_thresh = therm_limit;
4772                         data->sensor[i].max_op_thresh = therm_limit -
4773                                                         low_thresh_delta;
4774                 }
4775         }
4776         return status;
4777
4778 eeprom_err:
4779         ERROR_REPORT2(IXGBE_ERROR_INVALID_STATE,
4780                       "eeprom read at offset %d failed", offset);
4781         return IXGBE_NOT_IMPLEMENTED;
4782 }
4783
4784
4785 /**
4786  * ixgbe_dcb_get_rtrup2tc_generic - read rtrup2tc reg
4787  * @hw: pointer to hardware structure
4788  * @map: pointer to u8 arr for returning map
4789  *
4790  * Read the rtrup2tc HW register and resolve its content into map
4791  **/
4792 void ixgbe_dcb_get_rtrup2tc_generic(struct ixgbe_hw *hw, u8 *map)
4793 {
4794         u32 reg, i;
4795
4796         reg = IXGBE_READ_REG(hw, IXGBE_RTRUP2TC);
4797         for (i = 0; i < IXGBE_DCB_MAX_USER_PRIORITY; i++)
4798                 map[i] = IXGBE_RTRUP2TC_UP_MASK &
4799                         (reg >> (i * IXGBE_RTRUP2TC_UP_SHIFT));
4800         return;
4801 }
4802
4803 void ixgbe_disable_rx_generic(struct ixgbe_hw *hw)
4804 {
4805         u32 pfdtxgswc;
4806         u32 rxctrl;
4807
4808         rxctrl = IXGBE_READ_REG(hw, IXGBE_RXCTRL);
4809         if (rxctrl & IXGBE_RXCTRL_RXEN) {
4810                 if (hw->mac.type != ixgbe_mac_82598EB) {
4811                         pfdtxgswc = IXGBE_READ_REG(hw, IXGBE_PFDTXGSWC);
4812                         if (pfdtxgswc & IXGBE_PFDTXGSWC_VT_LBEN) {
4813                                 pfdtxgswc &= ~IXGBE_PFDTXGSWC_VT_LBEN;
4814                                 IXGBE_WRITE_REG(hw, IXGBE_PFDTXGSWC, pfdtxgswc);
4815                                 hw->mac.set_lben = true;
4816                         } else {
4817                                 hw->mac.set_lben = false;
4818                         }
4819                 }
4820                 rxctrl &= ~IXGBE_RXCTRL_RXEN;
4821                 IXGBE_WRITE_REG(hw, IXGBE_RXCTRL, rxctrl);
4822         }
4823 }
4824
4825 void ixgbe_enable_rx_generic(struct ixgbe_hw *hw)
4826 {
4827         u32 pfdtxgswc;
4828         u32 rxctrl;
4829
4830         rxctrl = IXGBE_READ_REG(hw, IXGBE_RXCTRL);
4831         IXGBE_WRITE_REG(hw, IXGBE_RXCTRL, (rxctrl | IXGBE_RXCTRL_RXEN));
4832
4833         if (hw->mac.type != ixgbe_mac_82598EB) {
4834                 if (hw->mac.set_lben) {
4835                         pfdtxgswc = IXGBE_READ_REG(hw, IXGBE_PFDTXGSWC);
4836                         pfdtxgswc |= IXGBE_PFDTXGSWC_VT_LBEN;
4837                         IXGBE_WRITE_REG(hw, IXGBE_PFDTXGSWC, pfdtxgswc);
4838                         hw->mac.set_lben = false;
4839                 }
4840         }
4841 }
4842
4843 /**
4844  * ixgbe_mng_enabled - Is the manageability engine enabled?
4845  * @hw: pointer to hardware structure
4846  *
4847  * Returns true if the manageability engine is enabled.
4848  **/
4849 bool ixgbe_mng_enabled(struct ixgbe_hw *hw)
4850 {
4851         u32 fwsm, manc, factps;
4852
4853         fwsm = IXGBE_READ_REG(hw, IXGBE_FWSM);
4854         if ((fwsm & IXGBE_FWSM_MODE_MASK) != IXGBE_FWSM_FW_MODE_PT)
4855                 return false;
4856
4857         manc = IXGBE_READ_REG(hw, IXGBE_MANC);
4858         if (!(manc & IXGBE_MANC_RCV_TCO_EN))
4859                 return false;
4860
4861         if (hw->mac.type <= ixgbe_mac_X540) {
4862                 factps = IXGBE_READ_REG(hw, IXGBE_FACTPS);
4863                 if (factps & IXGBE_FACTPS_MNGCG)
4864                         return false;
4865         }
4866
4867         return true;
4868 }