lib/librte_pmd_ixgbe/ixgbe/ixgbe_common.c

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