drivers/net/ixgbe/base/ixgbe_common.c

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