10 files changed, 307 insertions, 287 deletions

diff --git a/drivers/net/igb/e1000_82575.c b/drivers/net/igb/e1000_82575.c
index ac28dd5a4fd1..6158c0f3b205 100644
--- a/drivers/net/igb/e1000_82575.c
+++ b/drivers/net/igb/e1000_82575.c
@@ -53,7 +53,7 @@ static s32  igb_setup_fiber_serdes_link_82575(struct e1000_hw *);
 static s32  igb_write_phy_reg_sgmii_82575(struct e1000_hw *, u32, u16);
 static void igb_clear_hw_cntrs_82575(struct e1000_hw *);
 static s32  igb_acquire_swfw_sync_82575(struct e1000_hw *, u16);
-static s32  igb_configure_pcs_link_82575(struct e1000_hw *);
+static void igb_configure_pcs_link_82575(struct e1000_hw *);
 static s32  igb_get_pcs_speed_and_duplex_82575(struct e1000_hw *, u16 *,
                                                  u16 *);
 static s32  igb_get_phy_id_82575(struct e1000_hw *);
@@ -61,6 +61,7 @@ static void igb_release_swfw_sync_82575(struct e1000_hw *, u16);
 static bool igb_sgmii_active_82575(struct e1000_hw *);
 static s32  igb_reset_init_script_82575(struct e1000_hw *);
 static s32  igb_read_mac_addr_82575(struct e1000_hw *);
+static s32  igb_set_pcie_completion_timeout(struct e1000_hw *hw);
 
 static s32 igb_get_invariants_82575(struct e1000_hw *hw)
 {
@@ -84,6 +85,7 @@ static s32 igb_get_invariants_82575(struct e1000_hw *hw)
         case E1000_DEV_ID_82576_FIBER:
         case E1000_DEV_ID_82576_SERDES:
         case E1000_DEV_ID_82576_QUAD_COPPER:
+        case E1000_DEV_ID_82576_SERDES_QUAD:
                 mac->type = e1000_82576;
                 break;
         default:
@@ -170,6 +172,10 @@ static s32 igb_get_invariants_82575(struct e1000_hw *hw)
                 size = 14;
         nvm->word_size = 1 << size;
 
+        /* if 82576 then initialize mailbox parameters */
+        if (mac->type == e1000_82576)
+                igb_init_mbx_params_pf(hw);
+
         /* setup PHY parameters */
         if (phy->media_type != e1000_media_type_copper) {
                 phy->type = e1000_phy_none;
@@ -219,10 +225,6 @@ static s32 igb_get_invariants_82575(struct e1000_hw *hw)
                 return -E1000_ERR_PHY;
         }
 
-        /* if 82576 then initialize mailbox parameters */
-        if (mac->type == e1000_82576)
-                igb_init_mbx_params_pf(hw);
-
         return 0;
 }
 
@@ -764,98 +766,6 @@ static s32 igb_get_pcs_speed_and_duplex_82575(struct e1000_hw *hw, u16 *speed,
 }
 
 /**
- *  igb_init_rx_addrs_82575 - Initialize receive address's
- *  @hw: pointer to the HW structure
- *  @rar_count: receive address registers
- *
- *  Setups the receive address registers by setting the base receive address
- *  register to the devices MAC address and clearing all the other receive
- *  address registers to 0.
- **/
-static void igb_init_rx_addrs_82575(struct e1000_hw *hw, u16 rar_count)
-{
-        u32 i;
-        u8 addr[6] = {0,0,0,0,0,0};
-        /*
-         * This function is essentially the same as that of
-         * e1000_init_rx_addrs_generic. However it also takes care
-         * of the special case where the register offset of the
-         * second set of RARs begins elsewhere. This is implicitly taken care by
-         * function e1000_rar_set_generic.
-         */
-
-        hw_dbg("e1000_init_rx_addrs_82575");
-
-        /* Setup the receive address */
-        hw_dbg("Programming MAC Address into RAR[0]\n");
-        hw->mac.ops.rar_set(hw, hw->mac.addr, 0);
-
-        /* Zero out the other (rar_entry_count - 1) receive addresses */
-        hw_dbg("Clearing RAR[1-%u]\n", rar_count-1);
-        for (i = 1; i < rar_count; i++)
-            hw->mac.ops.rar_set(hw, addr, i);
-}
-
-/**
- *  igb_update_mc_addr_list - Update Multicast addresses
- *  @hw: pointer to the HW structure
- *  @mc_addr_list: array of multicast addresses to program
- *  @mc_addr_count: number of multicast addresses to program
- *  @rar_used_count: the first RAR register free to program
- *  @rar_count: total number of supported Receive Address Registers
- *
- *  Updates the Receive Address Registers and Multicast Table Array.
- *  The caller must have a packed mc_addr_list of multicast addresses.
- *  The parameter rar_count will usually be hw->mac.rar_entry_count
- *  unless there are workarounds that change this.
- **/
-void igb_update_mc_addr_list(struct e1000_hw *hw,
-                             u8 *mc_addr_list, u32 mc_addr_count,
-                             u32 rar_used_count, u32 rar_count)
-{
-        u32 hash_value;
-        u32 i;
-        u8 addr[6] = {0,0,0,0,0,0};
-        /*
-         * This function is essentially the same as that of 
-         * igb_update_mc_addr_list_generic. However it also takes care 
-         * of the special case where the register offset of the 
-         * second set of RARs begins elsewhere. This is implicitly taken care by 
-         * function e1000_rar_set_generic.
-         */
-
-        /*
-         * Load the first set of multicast addresses into the exact
-         * filters (RAR).  If there are not enough to fill the RAR
-         * array, clear the filters.
-         */
-        for (i = rar_used_count; i < rar_count; i++) {
-                if (mc_addr_count) {
-                        igb_rar_set(hw, mc_addr_list, i);
-                        mc_addr_count--;
-                        mc_addr_list += ETH_ALEN;
-                } else {
-                        igb_rar_set(hw, addr, i);
-                }
-        }
-
-        /* Clear the old settings from the MTA */
-        hw_dbg("Clearing MTA\n");
-        for (i = 0; i < hw->mac.mta_reg_count; i++) {
-                array_wr32(E1000_MTA, i, 0);
-                wrfl();
-        }
-
-        /* Load any remaining multicast addresses into the hash table. */
-        for (; mc_addr_count > 0; mc_addr_count--) {
-                hash_value = igb_hash_mc_addr(hw, mc_addr_list);
-                hw_dbg("Hash value = 0x%03X\n", hash_value);
-                igb_mta_set(hw, hash_value);
-                mc_addr_list += ETH_ALEN;
-        }
-}
-
-/**
  *  igb_shutdown_fiber_serdes_link_82575 - Remove link during power down
  *  @hw: pointer to the HW structure
  *
@@ -866,9 +776,7 @@ void igb_shutdown_fiber_serdes_link_82575(struct e1000_hw *hw)
 {
         u32 reg;
 
-        if (hw->mac.type != e1000_82576 ||
-            (hw->phy.media_type != e1000_media_type_fiber &&
-             hw->phy.media_type != e1000_media_type_internal_serdes))
+        if (hw->phy.media_type != e1000_media_type_internal_serdes)
                 return;
 
         /* if the management interface is not enabled, then power down */
@@ -911,6 +819,12 @@ static s32 igb_reset_hw_82575(struct e1000_hw *hw)
         if (ret_val)
                 hw_dbg("PCI-E Master disable polling has failed.\n");
 
+        /* set the completion timeout for interface */
+        ret_val = igb_set_pcie_completion_timeout(hw);
+        if (ret_val) {
+                hw_dbg("PCI-E Set completion timeout has failed.\n");
+        }
+
         hw_dbg("Masking off all interrupts\n");
         wr32(E1000_IMC, 0xffffffff);
 
@@ -943,7 +857,8 @@ static s32 igb_reset_hw_82575(struct e1000_hw *hw)
         wr32(E1000_IMC, 0xffffffff);
         icr = rd32(E1000_ICR);
 
-        igb_check_alt_mac_addr(hw);
+        /* Install any alternate MAC address into RAR0 */
+        ret_val = igb_check_alt_mac_addr(hw);
 
         return ret_val;
 }
@@ -972,7 +887,8 @@ static s32 igb_init_hw_82575(struct e1000_hw *hw)
         igb_clear_vfta(hw);
 
         /* Setup the receive address */
-        igb_init_rx_addrs_82575(hw, rar_count);
+        igb_init_rx_addrs(hw, rar_count);
+
         /* Zero out the Multicast HASH table */
         hw_dbg("Zeroing the MTA\n");
         for (i = 0; i < mac->mta_reg_count; i++)
@@ -1002,7 +918,7 @@ static s32 igb_init_hw_82575(struct e1000_hw *hw)
  **/
 static s32 igb_setup_copper_link_82575(struct e1000_hw *hw)
 {
-        u32 ctrl, led_ctrl;
+        u32 ctrl;
         s32  ret_val;
         bool link;
 
@@ -1017,11 +933,6 @@ static s32 igb_setup_copper_link_82575(struct e1000_hw *hw)
                 break;
         case e1000_phy_igp_3:
                 ret_val = igb_copper_link_setup_igp(hw);
-                /* Setup activity LED */
-                led_ctrl = rd32(E1000_LEDCTL);
-                led_ctrl &= IGP_ACTIVITY_LED_MASK;
-                led_ctrl |= (IGP_ACTIVITY_LED_ENABLE | IGP_LED3_MODE);
-                wr32(E1000_LEDCTL, led_ctrl);
                 break;
         default:
                 ret_val = -E1000_ERR_PHY;
@@ -1052,9 +963,7 @@ static s32 igb_setup_copper_link_82575(struct e1000_hw *hw)
                 }
         }
 
-        ret_val = igb_configure_pcs_link_82575(hw);
-        if (ret_val)
-                goto out;
+        igb_configure_pcs_link_82575(hw);
 
         /*
          * Check link status. Wait up to 100 microseconds for link to become
@@ -1163,14 +1072,14 @@ static s32 igb_setup_fiber_serdes_link_82575(struct e1000_hw *hw)
  *  independent interface (sgmii) is being used.  Configures the link
  *  for auto-negotiation or forces speed/duplex.
  **/
-static s32 igb_configure_pcs_link_82575(struct e1000_hw *hw)
+static void igb_configure_pcs_link_82575(struct e1000_hw *hw)
 {
         struct e1000_mac_info *mac = &hw->mac;
         u32 reg = 0;
 
         if (hw->phy.media_type != e1000_media_type_copper ||
             !(igb_sgmii_active_82575(hw)))
-                goto out;
+                return;
 
         /* For SGMII, we need to issue a PCS autoneg restart */
         reg = rd32(E1000_PCS_LCTL);
@@ -1213,9 +1122,6 @@ static s32 igb_configure_pcs_link_82575(struct e1000_hw *hw)
                        reg);
         }
         wr32(E1000_PCS_LCTL, reg);
-
-out:
-        return 0;
 }
 
 /**
@@ -1229,10 +1135,6 @@ out:
 static bool igb_sgmii_active_82575(struct e1000_hw *hw)
 {
         struct e1000_dev_spec_82575 *dev_spec = &hw->dev_spec._82575;
-
-        if (hw->mac.type != e1000_82575 && hw->mac.type != e1000_82576)
-                return false;
-
         return dev_spec->sgmii_active;
 }
 
@@ -1424,6 +1326,57 @@ void igb_rx_fifo_flush_82575(struct e1000_hw *hw)
 }
 
 /**
+ *  igb_set_pcie_completion_timeout - set pci-e completion timeout
+ *  @hw: pointer to the HW structure
+ *
+ *  The defaults for 82575 and 82576 should be in the range of 50us to 50ms,
+ *  however the hardware default for these parts is 500us to 1ms which is less
+ *  than the 10ms recommended by the pci-e spec.  To address this we need to
+ *  increase the value to either 10ms to 200ms for capability version 1 config,
+ *  or 16ms to 55ms for version 2.
+ **/
+static s32 igb_set_pcie_completion_timeout(struct e1000_hw *hw)
+{
+        u32 gcr = rd32(E1000_GCR);
+        s32 ret_val = 0;
+        u16 pcie_devctl2;
+
+        /* only take action if timeout value is defaulted to 0 */
+        if (gcr & E1000_GCR_CMPL_TMOUT_MASK)
+                goto out;
+
+        /*
+         * if capababilities version is type 1 we can write the
+         * timeout of 10ms to 200ms through the GCR register
+         */
+        if (!(gcr & E1000_GCR_CAP_VER2)) {
+                gcr |= E1000_GCR_CMPL_TMOUT_10ms;
+                goto out;
+        }
+
+        /*
+         * for version 2 capabilities we need to write the config space
+         * directly in order to set the completion timeout value for
+         * 16ms to 55ms
+         */
+        ret_val = igb_read_pcie_cap_reg(hw, PCIE_DEVICE_CONTROL2,
+                                        &pcie_devctl2);
+        if (ret_val)
+                goto out;
+
+        pcie_devctl2 |= PCIE_DEVICE_CONTROL2_16ms;
+
+        ret_val = igb_write_pcie_cap_reg(hw, PCIE_DEVICE_CONTROL2,
+                                         &pcie_devctl2);
+out:
+        /* disable completion timeout resend */
+        gcr &= ~E1000_GCR_CMPL_TMOUT_RESEND;
+
+        wr32(E1000_GCR, gcr);
+        return ret_val;
+}
+
+/**
  *  igb_vmdq_set_loopback_pf - enable or disable vmdq loopback
  *  @hw: pointer to the hardware struct
  *  @enable: state to enter, either enabled or disabled
diff --git a/drivers/net/igb/e1000_82575.h b/drivers/net/igb/e1000_82575.h
index 0f16abab2565..8a1e6597061f 100644
--- a/drivers/net/igb/e1000_82575.h
+++ b/drivers/net/igb/e1000_82575.h
@@ -28,10 +28,14 @@
 #ifndef _E1000_82575_H_
 #define _E1000_82575_H_
 
-void igb_update_mc_addr_list(struct e1000_hw*, u8*, u32, u32, u32);
 extern void igb_shutdown_fiber_serdes_link_82575(struct e1000_hw *hw);
 extern void igb_rx_fifo_flush_82575(struct e1000_hw *hw);
 
+#define ID_LED_DEFAULT_82575_SERDES ((ID_LED_DEF1_DEF2 << 12) | \
+                                     (ID_LED_DEF1_DEF2 <<  8) | \
+                                     (ID_LED_DEF1_DEF2 <<  4) | \
+                                     (ID_LED_OFF1_ON2))
+
 #define E1000_RAR_ENTRIES_82575   16
 #define E1000_RAR_ENTRIES_82576   24
 
diff --git a/drivers/net/igb/e1000_defines.h b/drivers/net/igb/e1000_defines.h
index 3bda3db73f1f..c85829355d50 100644
--- a/drivers/net/igb/e1000_defines.h
+++ b/drivers/net/igb/e1000_defines.h
@@ -435,6 +435,12 @@
 /* Flow Control */
 #define E1000_FCRTL_XONE 0x80000000     /* Enable XON frame transmission */
 
+/* PCI Express Control */
+#define E1000_GCR_CMPL_TMOUT_MASK       0x0000F000
+#define E1000_GCR_CMPL_TMOUT_10ms       0x00001000
+#define E1000_GCR_CMPL_TMOUT_RESEND     0x00010000
+#define E1000_GCR_CAP_VER2              0x00040000
+
 /* PHY Control Register */
 #define MII_CR_FULL_DUPLEX      0x0100  /* FDX =1, half duplex =0 */
 #define MII_CR_RESTART_AUTO_NEG 0x0200  /* Restart auto negotiation */
@@ -569,9 +575,11 @@
 
 /* PCI/PCI-X/PCI-EX Config space */
 #define PCIE_LINK_STATUS             0x12
+#define PCIE_DEVICE_CONTROL2         0x28
 
 #define PCIE_LINK_WIDTH_MASK         0x3F0
 #define PCIE_LINK_WIDTH_SHIFT        4
+#define PCIE_DEVICE_CONTROL2_16ms    0x0005
 
 #define PHY_REVISION_MASK      0xFFFFFFF0
 #define MAX_PHY_REG_ADDRESS    0x1F  /* 5 bit address bus (0-0x1F) */
diff --git a/drivers/net/igb/e1000_hw.h b/drivers/net/igb/e1000_hw.h
index 68aac20c31ca..119869b1124d 100644
--- a/drivers/net/igb/e1000_hw.h
+++ b/drivers/net/igb/e1000_hw.h
@@ -42,6 +42,7 @@ struct e1000_hw;
 #define E1000_DEV_ID_82576_SERDES             0x10E7
 #define E1000_DEV_ID_82576_QUAD_COPPER        0x10E8
 #define E1000_DEV_ID_82576_NS                 0x150A
+#define E1000_DEV_ID_82576_SERDES_QUAD        0x150D
 #define E1000_DEV_ID_82575EB_COPPER           0x10A7
 #define E1000_DEV_ID_82575EB_FIBER_SERDES     0x10A9
 #define E1000_DEV_ID_82575GB_QUAD_COPPER      0x10D6
@@ -61,8 +62,7 @@ enum e1000_mac_type {
 enum e1000_media_type {
         e1000_media_type_unknown = 0,
         e1000_media_type_copper = 1,
-        e1000_media_type_fiber = 2,
-        e1000_media_type_internal_serdes = 3,
+        e1000_media_type_internal_serdes = 2,
         e1000_num_media_types
 };
 
@@ -137,7 +137,7 @@ enum e1000_rev_polarity {
         e1000_rev_polarity_undefined = 0xFF
 };
 
-enum e1000_fc_type {
+enum e1000_fc_mode {
         e1000_fc_none = 0,
         e1000_fc_rx_pause,
         e1000_fc_tx_pause,
@@ -339,6 +339,10 @@ struct e1000_mac_info {
         u16 ifs_ratio;
         u16 ifs_step_size;
         u16 mta_reg_count;
+
+        /* Maximum size of the MTA register table in all supported adapters */
+        #define MAX_MTA_REG 128
+        u32 mta_shadow[MAX_MTA_REG];
         u16 rar_entry_count;
 
         u8  forced_speed_duplex;
@@ -425,8 +429,8 @@ struct e1000_fc_info {
         u16 pause_time;     /* Flow control pause timer */
         bool send_xon;      /* Flow control send XON */
         bool strict_ieee;   /* Strict IEEE mode */
-        enum e1000_fc_type type; /* Type of flow control */
-        enum e1000_fc_type original_type;
+        enum e1000_fc_mode current_mode; /* Type of flow control */
+        enum e1000_fc_mode requested_mode;
 };
 
 struct e1000_mbx_operations {
@@ -495,5 +499,7 @@ extern char *igb_get_hw_dev_name(struct e1000_hw *hw);
 #else
 #define hw_dbg(format, arg...)
 #endif
-
 #endif
+/* These functions must be implemented by drivers */
+s32  igb_read_pcie_cap_reg(struct e1000_hw *hw, u32 reg, u16 *value);
+s32  igb_write_pcie_cap_reg(struct e1000_hw *hw, u32 reg, u16 *value);
diff --git a/drivers/net/igb/e1000_mac.c b/drivers/net/igb/e1000_mac.c
index 472f3f124840..a0231cd079f1 100644
--- a/drivers/net/igb/e1000_mac.c
+++ b/drivers/net/igb/e1000_mac.c
@@ -37,20 +37,6 @@
 static s32 igb_set_default_fc(struct e1000_hw *hw);
 static s32 igb_set_fc_watermarks(struct e1000_hw *hw);
 
-static s32 igb_read_pcie_cap_reg(struct e1000_hw *hw, u32 reg, u16 *value)
-{
-        struct igb_adapter *adapter = hw->back;
-        u16 cap_offset;
-
-        cap_offset = pci_find_capability(adapter->pdev, PCI_CAP_ID_EXP);
-        if (!cap_offset)
-                return -E1000_ERR_CONFIG;
-
-        pci_read_config_word(adapter->pdev, cap_offset + reg, value);
-
-        return 0;
-}
-
 /**
  *  igb_get_bus_info_pcie - Get PCIe bus information
  *  @hw: pointer to the HW structure
@@ -118,6 +104,31 @@ static void igb_write_vfta(struct e1000_hw *hw, u32 offset, u32 value)
 }
 
 /**
+ *  igb_init_rx_addrs - Initialize receive address's
+ *  @hw: pointer to the HW structure
+ *  @rar_count: receive address registers
+ *
+ *  Setups the receive address registers by setting the base receive address
+ *  register to the devices MAC address and clearing all the other receive
+ *  address registers to 0.
+ **/
+void igb_init_rx_addrs(struct e1000_hw *hw, u16 rar_count)
+{
+        u32 i;
+        u8 mac_addr[ETH_ALEN] = {0};
+
+        /* Setup the receive address */
+        hw_dbg("Programming MAC Address into RAR[0]\n");
+
+        hw->mac.ops.rar_set(hw, hw->mac.addr, 0);
+
+        /* Zero out the other (rar_entry_count - 1) receive addresses */
+        hw_dbg("Clearing RAR[1-%u]\n", rar_count-1);
+        for (i = 1; i < rar_count; i++)
+                hw->mac.ops.rar_set(hw, mac_addr, i);
+}
+
+/**
  *  igb_vfta_set - enable or disable vlan in VLAN filter table
  *  @hw: pointer to the HW structure
  *  @vid: VLAN id to add or remove
@@ -275,6 +286,41 @@ void igb_mta_set(struct e1000_hw *hw, u32 hash_value)
 }
 
 /**
+ *  igb_update_mc_addr_list - Update Multicast addresses
+ *  @hw: pointer to the HW structure
+ *  @mc_addr_list: array of multicast addresses to program
+ *  @mc_addr_count: number of multicast addresses to program
+ *
+ *  Updates entire Multicast Table Array.
+ *  The caller must have a packed mc_addr_list of multicast addresses.
+ **/
+void igb_update_mc_addr_list(struct e1000_hw *hw,
+                             u8 *mc_addr_list, u32 mc_addr_count)
+{
+        u32 hash_value, hash_bit, hash_reg;
+        int i;
+
+        /* clear mta_shadow */
+        memset(&hw->mac.mta_shadow, 0, sizeof(hw->mac.mta_shadow));
+
+        /* update mta_shadow from mc_addr_list */
+        for (i = 0; (u32) i < mc_addr_count; i++) {
+                hash_value = igb_hash_mc_addr(hw, mc_addr_list);
+
+                hash_reg = (hash_value >> 5) & (hw->mac.mta_reg_count - 1);
+                hash_bit = hash_value & 0x1F;
+
+                hw->mac.mta_shadow[hash_reg] |= (1 << hash_bit);
+                mc_addr_list += (ETH_ALEN);
+        }
+
+        /* replace the entire MTA table */
+        for (i = hw->mac.mta_reg_count - 1; i >= 0; i--)
+                array_wr32(E1000_MTA, i, hw->mac.mta_shadow[i]);
+        wrfl();
+}
+
+/**
  *  igb_hash_mc_addr - Generate a multicast hash value
  *  @hw: pointer to the HW structure
  *  @mc_addr: pointer to a multicast address
@@ -490,18 +536,24 @@ s32 igb_setup_link(struct e1000_hw *hw)
         if (igb_check_reset_block(hw))
                 goto out;
 
-        ret_val = igb_set_default_fc(hw);
-        if (ret_val)
-                goto out;
+        /*
+         * If requested flow control is set to default, set flow control
+         * based on the EEPROM flow control settings.
+         */
+        if (hw->fc.requested_mode == e1000_fc_default) {
+                ret_val = igb_set_default_fc(hw);
+                if (ret_val)
+                        goto out;
+        }
 
         /*
          * We want to save off the original Flow Control configuration just
          * in case we get disconnected and then reconnected into a different
          * hub or switch with different Flow Control capabilities.
          */
-        hw->fc.original_type = hw->fc.type;
+        hw->fc.current_mode = hw->fc.requested_mode;
 
-        hw_dbg("After fix-ups FlowControl is now = %x\n", hw->fc.type);
+        hw_dbg("After fix-ups FlowControl is now = %x\n", hw->fc.current_mode);
 
         /* Call the necessary media_type subroutine to configure the link. */
         ret_val = hw->mac.ops.setup_physical_interface(hw);
@@ -568,7 +620,7 @@ static s32 igb_set_fc_watermarks(struct e1000_hw *hw)
          * ability to transmit pause frames is not enabled, then these
          * registers will be set to 0.
          */
-        if (hw->fc.type & e1000_fc_tx_pause) {
+        if (hw->fc.current_mode & e1000_fc_tx_pause) {
                 /*
                  * We need to set up the Receive Threshold high and low water
                  * marks as well as (optionally) enabling the transmission of
@@ -615,12 +667,12 @@ static s32 igb_set_default_fc(struct e1000_hw *hw)
         }
 
         if ((nvm_data & NVM_WORD0F_PAUSE_MASK) == 0)
-                hw->fc.type = e1000_fc_none;
+                hw->fc.requested_mode = e1000_fc_none;
         else if ((nvm_data & NVM_WORD0F_PAUSE_MASK) ==
                  NVM_WORD0F_ASM_DIR)
-                hw->fc.type = e1000_fc_tx_pause;
+                hw->fc.requested_mode = e1000_fc_tx_pause;
         else
-                hw->fc.type = e1000_fc_full;
+                hw->fc.requested_mode = e1000_fc_full;
 
 out:
         return ret_val;
@@ -650,7 +702,7 @@ s32 igb_force_mac_fc(struct e1000_hw *hw)
          * receive flow control.
          *
          * The "Case" statement below enables/disable flow control
-         * according to the "hw->fc.type" parameter.
+         * according to the "hw->fc.current_mode" parameter.
          *
          * The possible values of the "fc" parameter are:
          *      0:  Flow control is completely disabled
@@ -661,9 +713,9 @@ s32 igb_force_mac_fc(struct e1000_hw *hw)
          *      3:  Both Rx and TX flow control (symmetric) is enabled.
          *  other:  No other values should be possible at this point.
          */
-        hw_dbg("hw->fc.type = %u\n", hw->fc.type);
+        hw_dbg("hw->fc.current_mode = %u\n", hw->fc.current_mode);
 
-        switch (hw->fc.type) {
+        switch (hw->fc.current_mode) {
         case e1000_fc_none:
                 ctrl &= (~(E1000_CTRL_TFCE | E1000_CTRL_RFCE));
                 break;
@@ -713,8 +765,7 @@ s32 igb_config_fc_after_link_up(struct e1000_hw *hw)
          * configuration of the MAC to match the "fc" parameter.
          */
         if (mac->autoneg_failed) {
-                if (hw->phy.media_type == e1000_media_type_fiber ||
-                    hw->phy.media_type == e1000_media_type_internal_serdes)
+                if (hw->phy.media_type == e1000_media_type_internal_serdes)
                         ret_val = igb_force_mac_fc(hw);
         } else {
                 if (hw->phy.media_type == e1000_media_type_copper)
@@ -812,11 +863,11 @@ s32 igb_config_fc_after_link_up(struct e1000_hw *hw)
                          * ONLY. Hence, we must now check to see if we need to
                          * turn OFF  the TRANSMISSION of PAUSE frames.
                          */
-                        if (hw->fc.original_type == e1000_fc_full) {
-                                hw->fc.type = e1000_fc_full;
+                        if (hw->fc.requested_mode == e1000_fc_full) {
+                                hw->fc.current_mode = e1000_fc_full;
                                 hw_dbg("Flow Control = FULL.\r\n");
                         } else {
-                                hw->fc.type = e1000_fc_rx_pause;
+                                hw->fc.current_mode = e1000_fc_rx_pause;
                                 hw_dbg("Flow Control = "
                                        "RX PAUSE frames only.\r\n");
                         }
@@ -833,7 +884,7 @@ s32 igb_config_fc_after_link_up(struct e1000_hw *hw)
                           (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
                           (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
                           (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) {
-                        hw->fc.type = e1000_fc_tx_pause;
+                        hw->fc.current_mode = e1000_fc_tx_pause;
                         hw_dbg("Flow Control = TX PAUSE frames only.\r\n");
                 }
                 /*
@@ -848,7 +899,7 @@ s32 igb_config_fc_after_link_up(struct e1000_hw *hw)
                          (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&
                          !(mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&
                          (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) {
-                        hw->fc.type = e1000_fc_rx_pause;
+                        hw->fc.current_mode = e1000_fc_rx_pause;
                         hw_dbg("Flow Control = RX PAUSE frames only.\r\n");
                 }
                 /*
@@ -872,13 +923,13 @@ s32 igb_config_fc_after_link_up(struct e1000_hw *hw)
                  * be asked to delay transmission of packets than asking
                  * our link partner to pause transmission of frames.
                  */
-                else if ((hw->fc.original_type == e1000_fc_none ||
-                          hw->fc.original_type == e1000_fc_tx_pause) ||
+                else if ((hw->fc.requested_mode == e1000_fc_none ||
+                          hw->fc.requested_mode == e1000_fc_tx_pause) ||
                          hw->fc.strict_ieee) {
-                        hw->fc.type = e1000_fc_none;
+                        hw->fc.current_mode = e1000_fc_none;
                         hw_dbg("Flow Control = NONE.\r\n");
                 } else {
-                        hw->fc.type = e1000_fc_rx_pause;
+                        hw->fc.current_mode = e1000_fc_rx_pause;
                         hw_dbg("Flow Control = RX PAUSE frames only.\r\n");
                 }
 
@@ -894,7 +945,7 @@ s32 igb_config_fc_after_link_up(struct e1000_hw *hw)
                 }
 
                 if (duplex == HALF_DUPLEX)
-                        hw->fc.type = e1000_fc_none;
+                        hw->fc.current_mode = e1000_fc_none;
 
                 /*
                  * Now we call a subroutine to actually force the MAC
@@ -1065,9 +1116,17 @@ static s32 igb_valid_led_default(struct e1000_hw *hw, u16 *data)
                 goto out;
         }
 
-        if (*data == ID_LED_RESERVED_0000 || *data == ID_LED_RESERVED_FFFF)
-                *data = ID_LED_DEFAULT;
-
+        if (*data == ID_LED_RESERVED_0000 || *data == ID_LED_RESERVED_FFFF) {
+                switch(hw->phy.media_type) {
+                case e1000_media_type_internal_serdes:
+                        *data = ID_LED_DEFAULT_82575_SERDES;
+                        break;
+                case e1000_media_type_copper:
+                default:
+                        *data = ID_LED_DEFAULT;
+                        break;
+                }
+        }
 out:
         return ret_val;
 }
@@ -1161,22 +1220,16 @@ s32 igb_blink_led(struct e1000_hw *hw)
         u32 ledctl_blink = 0;
         u32 i;
 
-        if (hw->phy.media_type == e1000_media_type_fiber) {
-                /* always blink LED0 for PCI-E fiber */
-                ledctl_blink = E1000_LEDCTL_LED0_BLINK |
-                     (E1000_LEDCTL_MODE_LED_ON << E1000_LEDCTL_LED0_MODE_SHIFT);
-        } else {
-                /*
-                 * set the blink bit for each LED that's "on" (0x0E)
-                 * in ledctl_mode2
-                 */
-                ledctl_blink = hw->mac.ledctl_mode2;
-                for (i = 0; i < 4; i++)
-                        if (((hw->mac.ledctl_mode2 >> (i * 8)) & 0xFF) ==
-                            E1000_LEDCTL_MODE_LED_ON)
-                                ledctl_blink |= (E1000_LEDCTL_LED0_BLINK <<
-                                                 (i * 8));
-        }
+        /*
+         * set the blink bit for each LED that's "on" (0x0E)
+         * in ledctl_mode2
+         */
+        ledctl_blink = hw->mac.ledctl_mode2;
+        for (i = 0; i < 4; i++)
+                if (((hw->mac.ledctl_mode2 >> (i * 8)) & 0xFF) ==
+                    E1000_LEDCTL_MODE_LED_ON)
+                        ledctl_blink |= (E1000_LEDCTL_LED0_BLINK <<
+                                         (i * 8));
 
         wr32(E1000_LEDCTL, ledctl_blink);
 
@@ -1191,15 +1244,7 @@ s32 igb_blink_led(struct e1000_hw *hw)
  **/
 s32 igb_led_off(struct e1000_hw *hw)
 {
-        u32 ctrl;
-
         switch (hw->phy.media_type) {
-        case e1000_media_type_fiber:
-                ctrl = rd32(E1000_CTRL);
-                ctrl |= E1000_CTRL_SWDPIN0;
-                ctrl |= E1000_CTRL_SWDPIO0;
-                wr32(E1000_CTRL, ctrl);
-                break;
         case e1000_media_type_copper:
                 wr32(E1000_LEDCTL, hw->mac.ledctl_mode1);
                 break;
diff --git a/drivers/net/igb/e1000_mac.h b/drivers/net/igb/e1000_mac.h
index 1d690b4c9ae4..7518af8cbbf5 100644
--- a/drivers/net/igb/e1000_mac.h
+++ b/drivers/net/igb/e1000_mac.h
@@ -51,6 +51,8 @@ s32  igb_get_speed_and_duplex_copper(struct e1000_hw *hw, u16 *speed,
                                        u16 *duplex);
 s32  igb_id_led_init(struct e1000_hw *hw);
 s32  igb_led_off(struct e1000_hw *hw);
+void igb_update_mc_addr_list(struct e1000_hw *hw,
+                             u8 *mc_addr_list, u32 mc_addr_count);
 s32  igb_setup_link(struct e1000_hw *hw);
 s32  igb_validate_mdi_setting(struct e1000_hw *hw);
 s32  igb_write_8bit_ctrl_reg(struct e1000_hw *hw, u32 reg,
@@ -60,6 +62,7 @@ void igb_clear_hw_cntrs_base(struct e1000_hw *hw);
 void igb_clear_vfta(struct e1000_hw *hw);
 s32  igb_vfta_set(struct e1000_hw *hw, u32 vid, bool add);
 void igb_config_collision_dist(struct e1000_hw *hw);
+void igb_init_rx_addrs(struct e1000_hw *hw, u16 rar_count);
 void igb_mta_set(struct e1000_hw *hw, u32 hash_value);
 void igb_put_hw_semaphore(struct e1000_hw *hw);
 void igb_rar_set(struct e1000_hw *hw, u8 *addr, u32 index);
diff --git a/drivers/net/igb/e1000_phy.c b/drivers/net/igb/e1000_phy.c
index f50fac25be40..c1f4da630420 100644
--- a/drivers/net/igb/e1000_phy.c
+++ b/drivers/net/igb/e1000_phy.c
@@ -735,7 +735,7 @@ static s32 igb_phy_setup_autoneg(struct e1000_hw *hw)
          *  other:  No software override.  The flow control configuration
          *          in the EEPROM is used.
          */
-        switch (hw->fc.type) {
+        switch (hw->fc.current_mode) {
         case e1000_fc_none:
                 /*
                  * Flow control (RX & TX) is completely disabled by a
@@ -992,7 +992,7 @@ static void igb_phy_force_speed_duplex_setup(struct e1000_hw *hw,
         u32 ctrl;
 
         /* Turn off flow control when forcing speed/duplex */
-        hw->fc.type = e1000_fc_none;
+        hw->fc.current_mode = e1000_fc_none;
 
         /* Force speed/duplex on the mac */
         ctrl = rd32(E1000_CTRL);
diff --git a/drivers/net/igb/e1000_regs.h b/drivers/net/igb/e1000_regs.h
index 6e5924511e40..345d1442d6d6 100644
--- a/drivers/net/igb/e1000_regs.h
+++ b/drivers/net/igb/e1000_regs.h
@@ -305,6 +305,7 @@ enum {
 #define E1000_CCMCTL      0x05B48 /* CCM Control Register */
 #define E1000_GIOCTL      0x05B44 /* GIO Analog Control Register */
 #define E1000_SCCTL       0x05B4C /* PCIc PLL Configuration Register */
+#define E1000_GCR         0x05B00 /* PCI-Ex Control */
 #define E1000_FACTPS    0x05B30 /* Function Active and Power State to MNG */
 #define E1000_SWSM      0x05B50 /* SW Semaphore */
 #define E1000_FWSM      0x05B54 /* FW Semaphore */
diff --git a/drivers/net/igb/igb_ethtool.c b/drivers/net/igb/igb_ethtool.c
index 9598ac09f4b8..114ccab1f2be 100644
--- a/drivers/net/igb/igb_ethtool.c
+++ b/drivers/net/igb/igb_ethtool.c
@@ -168,8 +168,7 @@ static int igb_get_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)
                 ecmd->duplex = -1;
         }
 
-        ecmd->autoneg = ((hw->phy.media_type == e1000_media_type_fiber) ||
-                         hw->mac.autoneg) ? AUTONEG_ENABLE : AUTONEG_DISABLE;
+        ecmd->autoneg = hw->mac.autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE;
         return 0;
 }
 
@@ -191,23 +190,20 @@ static int igb_set_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)
 
         if (ecmd->autoneg == AUTONEG_ENABLE) {
                 hw->mac.autoneg = 1;
-                if (hw->phy.media_type == e1000_media_type_fiber)
-                        hw->phy.autoneg_advertised = ADVERTISED_1000baseT_Full |
-                                                     ADVERTISED_FIBRE |
-                                                     ADVERTISED_Autoneg;
-                else
-                        hw->phy.autoneg_advertised = ecmd->advertising |
-                                                     ADVERTISED_TP |
-                                                     ADVERTISED_Autoneg;
+                hw->phy.autoneg_advertised = ecmd->advertising |
+                                             ADVERTISED_TP |
+                                             ADVERTISED_Autoneg;
                 ecmd->advertising = hw->phy.autoneg_advertised;
-        } else
+                if (adapter->fc_autoneg)
+                        hw->fc.requested_mode = e1000_fc_default;
+        } else {
                 if (igb_set_spd_dplx(adapter, ecmd->speed + ecmd->duplex)) {
                         clear_bit(__IGB_RESETTING, &adapter->state);
                         return -EINVAL;
                 }
+        }
 
         /* reset the link */
-
         if (netif_running(adapter->netdev)) {
                 igb_down(adapter);
                 igb_up(adapter);
@@ -227,11 +223,11 @@ static void igb_get_pauseparam(struct net_device *netdev,
         pause->autoneg =
                 (adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE);
 
-        if (hw->fc.type == e1000_fc_rx_pause)
+        if (hw->fc.current_mode == e1000_fc_rx_pause)
                 pause->rx_pause = 1;
-        else if (hw->fc.type == e1000_fc_tx_pause)
+        else if (hw->fc.current_mode == e1000_fc_tx_pause)
                 pause->tx_pause = 1;
-        else if (hw->fc.type == e1000_fc_full) {
+        else if (hw->fc.current_mode == e1000_fc_full) {
                 pause->rx_pause = 1;
                 pause->tx_pause = 1;
         }
@@ -249,26 +245,28 @@ static int igb_set_pauseparam(struct net_device *netdev,
         while (test_and_set_bit(__IGB_RESETTING, &adapter->state))
                 msleep(1);
 
-        if (pause->rx_pause && pause->tx_pause)
-                hw->fc.type = e1000_fc_full;
-        else if (pause->rx_pause && !pause->tx_pause)
-                hw->fc.type = e1000_fc_rx_pause;
-        else if (!pause->rx_pause && pause->tx_pause)
-                hw->fc.type = e1000_fc_tx_pause;
-        else if (!pause->rx_pause && !pause->tx_pause)
-                hw->fc.type = e1000_fc_none;
-
-        hw->fc.original_type = hw->fc.type;
-
         if (adapter->fc_autoneg == AUTONEG_ENABLE) {
+                hw->fc.requested_mode = e1000_fc_default;
                 if (netif_running(adapter->netdev)) {
                         igb_down(adapter);
                         igb_up(adapter);
                 } else
                         igb_reset(adapter);
-        } else
-                retval = ((hw->phy.media_type == e1000_media_type_fiber) ?
-                          igb_setup_link(hw) : igb_force_mac_fc(hw));
+        } else {
+                if (pause->rx_pause && pause->tx_pause)
+                        hw->fc.requested_mode = e1000_fc_full;
+                else if (pause->rx_pause && !pause->tx_pause)
+                        hw->fc.requested_mode = e1000_fc_rx_pause;
+                else if (!pause->rx_pause && pause->tx_pause)
+                        hw->fc.requested_mode = e1000_fc_tx_pause;
+                else if (!pause->rx_pause && !pause->tx_pause)
+                        hw->fc.requested_mode = e1000_fc_none;
+
+                hw->fc.current_mode = hw->fc.requested_mode;
+
+                retval = ((hw->phy.media_type == e1000_media_type_copper) ?
+                          igb_force_mac_fc(hw) : igb_setup_link(hw));
+        }
 
         clear_bit(__IGB_RESETTING, &adapter->state);
         return retval;
@@ -1483,8 +1481,7 @@ static int igb_setup_loopback_test(struct igb_adapter *adapter)
         struct e1000_hw *hw = &adapter->hw;
         u32 reg;
 
-        if (hw->phy.media_type == e1000_media_type_fiber ||
-            hw->phy.media_type == e1000_media_type_internal_serdes) {
+        if (hw->phy.media_type == e1000_media_type_internal_serdes) {
                 reg = rd32(E1000_RCTL);
                 reg |= E1000_RCTL_LBM_TCVR;
                 wr32(E1000_RCTL, reg);
@@ -1843,7 +1840,6 @@ static void igb_get_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
 static int igb_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
 {
         struct igb_adapter *adapter = netdev_priv(netdev);
-        struct e1000_hw *hw = &adapter->hw;
 
         if (wol->wolopts & (WAKE_PHY | WAKE_ARP | WAKE_MAGICSECURE))
                 return -EOPNOTSUPP;
@@ -1852,11 +1848,6 @@ static int igb_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
             !device_can_wakeup(&adapter->pdev->dev))
                 return wol->wolopts ? -EOPNOTSUPP : 0;
 
-        switch (hw->device_id) {
-        default:
-                break;
-        }
-
         /* these settings will always override what we currently have */
         adapter->wol = 0;
 
diff --git a/drivers/net/igb/igb_main.c b/drivers/net/igb/igb_main.c
index adb09d32625d..fb3273517587 100644
--- a/drivers/net/igb/igb_main.c
+++ b/drivers/net/igb/igb_main.c
@@ -65,6 +65,7 @@ static struct pci_device_id igb_pci_tbl[] = {
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_NS), board_82575 },
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_FIBER), board_82575 },
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_SERDES), board_82575 },
+        { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_SERDES_QUAD), board_82575 },
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_QUAD_COPPER), board_82575 },
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_82575EB_COPPER), board_82575 },
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_82575EB_FIBER_SERDES), board_82575 },
@@ -127,7 +128,7 @@ static void igb_restore_vlan(struct igb_adapter *);
 static void igb_ping_all_vfs(struct igb_adapter *);
 static void igb_msg_task(struct igb_adapter *);
 static int igb_rcv_msg_from_vf(struct igb_adapter *, u32);
-static void igb_set_mc_list_pools(struct igb_adapter *, int, u16);
+static inline void igb_set_rah_pool(struct e1000_hw *, int , int);
 static void igb_vmm_control(struct igb_adapter *);
 static int igb_set_vf_mac(struct igb_adapter *adapter, int, unsigned char *);
 static void igb_restore_vf_multicasts(struct igb_adapter *adapter);
@@ -1129,7 +1130,7 @@ void igb_reset(struct igb_adapter *adapter)
         }
         fc->pause_time = 0xFFFF;
         fc->send_xon = 1;
-        fc->type = fc->original_type;
+        fc->current_mode = fc->requested_mode;
 
         /* disable receive for all VFs and wait one second */
         if (adapter->vfs_allocated_count) {
@@ -1426,8 +1427,8 @@ static int __devinit igb_probe(struct pci_dev *pdev,
         hw->mac.autoneg = true;
         hw->phy.autoneg_advertised = 0x2f;
 
-        hw->fc.original_type = e1000_fc_default;
-        hw->fc.type = e1000_fc_default;
+        hw->fc.requested_mode = e1000_fc_default;
+        hw->fc.current_mode = e1000_fc_default;
 
         adapter->itr_setting = IGB_DEFAULT_ITR;
         adapter->itr = IGB_START_ITR;
@@ -2535,7 +2536,6 @@ static void igb_set_multi(struct net_device *netdev)
 {
         struct igb_adapter *adapter = netdev_priv(netdev);
         struct e1000_hw *hw = &adapter->hw;
-        struct e1000_mac_info *mac = &hw->mac;
         struct dev_mc_list *mc_ptr;
         u8  *mta_list = NULL;
         u32 rctl;
@@ -2558,13 +2558,18 @@ static void igb_set_multi(struct net_device *netdev)
         }
         wr32(E1000_RCTL, rctl);
 
-        if (netdev->mc_count) {
-                mta_list = kzalloc(netdev->mc_count * 6, GFP_ATOMIC);
-                if (!mta_list) {
-                        dev_err(&adapter->pdev->dev,
-                                "failed to allocate multicast filter list\n");
-                        return;
-                }
+        if (!netdev->mc_count) {
+                /* nothing to program, so clear mc list */
+                igb_update_mc_addr_list(hw, NULL, 0);
+                igb_restore_vf_multicasts(adapter);
+                return;
+        }
+
+        mta_list = kzalloc(netdev->mc_count * 6, GFP_ATOMIC);
+        if (!mta_list) {
+                dev_err(&adapter->pdev->dev,
+                        "failed to allocate multicast filter list\n");
+                return;
         }
 
         /* The shared function expects a packed array of only addresses. */
@@ -2576,14 +2581,9 @@ static void igb_set_multi(struct net_device *netdev)
                 memcpy(mta_list + (i*ETH_ALEN), mc_ptr->dmi_addr, ETH_ALEN);
                 mc_ptr = mc_ptr->next;
         }
-        igb_update_mc_addr_list(hw, mta_list, i,
-                                adapter->vfs_allocated_count + 1,
-                                mac->rar_entry_count);
-
-        igb_set_mc_list_pools(adapter, i, mac->rar_entry_count);
-        igb_restore_vf_multicasts(adapter);
-
+        igb_update_mc_addr_list(hw, mta_list, i);
         kfree(mta_list);
+        igb_restore_vf_multicasts(adapter);
 }
 
 /* Need to wait a few seconds after link up to get diagnostic information from
@@ -2618,10 +2618,6 @@ static bool igb_has_link(struct igb_adapter *adapter)
                         link_active = true;
                 }
                 break;
-        case e1000_media_type_fiber:
-                ret_val = hw->mac.ops.check_for_link(hw);
-                link_active = !!(rd32(E1000_STATUS) & E1000_STATUS_LU);
-                break;
         case e1000_media_type_internal_serdes:
                 ret_val = hw->mac.ops.check_for_link(hw);
                 link_active = hw->mac.serdes_has_link;
@@ -4542,6 +4538,20 @@ static inline void igb_rx_checksum_adv(struct igb_adapter *adapter,
         adapter->hw_csum_good++;
 }
 
+static inline u16 igb_get_hlen(struct igb_adapter *adapter,
+                               union e1000_adv_rx_desc *rx_desc)
+{
+        /* HW will not DMA in data larger than the given buffer, even if it
+         * parses the (NFS, of course) header to be larger.  In that case, it
+         * fills the header buffer and spills the rest into the page.
+         */
+        u16 hlen = (le16_to_cpu(rx_desc->wb.lower.lo_dword.hdr_info) &
+                   E1000_RXDADV_HDRBUFLEN_MASK) >> E1000_RXDADV_HDRBUFLEN_SHIFT;
+        if (hlen > adapter->rx_ps_hdr_size)
+                hlen = adapter->rx_ps_hdr_size;
+        return hlen;
+}
+
 static bool igb_clean_rx_irq_adv(struct igb_ring *rx_ring,
                                  int *work_done, int budget)
 {
@@ -4556,7 +4566,8 @@ static bool igb_clean_rx_irq_adv(struct igb_ring *rx_ring,
         int cleaned_count = 0;
         unsigned int total_bytes = 0, total_packets = 0;
         unsigned int i;
-        u32 length, hlen, staterr;
+        u32 staterr;
+        u16 length;
 
         i = rx_ring->next_to_clean;
         buffer_info = &rx_ring->buffer_info[i];
@@ -4593,17 +4604,8 @@ static bool igb_clean_rx_irq_adv(struct igb_ring *rx_ring,
                         goto send_up;
                 }
 
-                /* HW will not DMA in data larger than the given buffer, even
-                 * if it parses the (NFS, of course) header to be larger.  In
-                 * that case, it fills the header buffer and spills the rest
-                 * into the page.
-                 */
-                hlen = (le16_to_cpu(rx_desc->wb.lower.lo_dword.hdr_info) &
-                  E1000_RXDADV_HDRBUFLEN_MASK) >> E1000_RXDADV_HDRBUFLEN_SHIFT;
-                if (hlen > adapter->rx_ps_hdr_size)
-                        hlen = adapter->rx_ps_hdr_size;
-
-                if (!skb_shinfo(skb)->nr_frags) {
+                if (buffer_info->dma) {
+                        u16 hlen = igb_get_hlen(adapter, rx_desc);
                         pci_unmap_single(pdev, buffer_info->dma,
                                          adapter->rx_ps_hdr_size,
                                          PCI_DMA_FROMDEVICE);
@@ -5033,6 +5035,34 @@ static int igb_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
         }
 }
 
+s32 igb_read_pcie_cap_reg(struct e1000_hw *hw, u32 reg, u16 *value)
+{
+        struct igb_adapter *adapter = hw->back;
+        u16 cap_offset;
+
+        cap_offset = pci_find_capability(adapter->pdev, PCI_CAP_ID_EXP);
+        if (!cap_offset)
+                return -E1000_ERR_CONFIG;
+
+        pci_read_config_word(adapter->pdev, cap_offset + reg, value);
+
+        return 0;
+}
+
+s32 igb_write_pcie_cap_reg(struct e1000_hw *hw, u32 reg, u16 *value)
+{
+        struct igb_adapter *adapter = hw->back;
+        u16 cap_offset;
+
+        cap_offset = pci_find_capability(adapter->pdev, PCI_CAP_ID_EXP);
+        if (!cap_offset)
+                return -E1000_ERR_CONFIG;
+
+        pci_write_config_word(adapter->pdev, cap_offset + reg, *value);
+
+        return 0;
+}
+
 static void igb_vlan_rx_register(struct net_device *netdev,
                                  struct vlan_group *grp)
 {
@@ -5136,14 +5166,6 @@ int igb_set_spd_dplx(struct igb_adapter *adapter, u16 spddplx)
 
         mac->autoneg = 0;
 
-        /* Fiber NICs only allow 1000 gbps Full duplex */
-        if ((adapter->hw.phy.media_type == e1000_media_type_fiber) &&
-                spddplx != (SPEED_1000 + DUPLEX_FULL)) {
-                dev_err(&adapter->pdev->dev,
-                        "Unsupported Speed/Duplex configuration\n");
-                return -EINVAL;
-        }
-
         switch (spddplx) {
         case SPEED_10 + DUPLEX_HALF:
                 mac->forced_speed_duplex = ADVERTISE_10_HALF;
@@ -5452,19 +5474,6 @@ static void igb_io_resume(struct pci_dev *pdev)
         igb_get_hw_control(adapter);
 }
 
-static void igb_set_mc_list_pools(struct igb_adapter *adapter,
-                                  int entry_count, u16 total_rar_filters)
-{
-        struct e1000_hw *hw = &adapter->hw;
-        int i = adapter->vfs_allocated_count + 1;
-
-        if ((i + entry_count) < total_rar_filters)
-                total_rar_filters = i + entry_count;
-
-        for (; i < total_rar_filters; i++)
-                igb_set_rah_pool(hw, adapter->vfs_allocated_count, i);
-}
-
 static int igb_set_vf_mac(struct igb_adapter *adapter,
                           int vf, unsigned char *mac_addr)
 {