sys/dev/ixgbe/ixgbe_common.c

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