9 files changed, 237 insertions, 174 deletions

diff --git a/drivers/net/e1000e/82571.c b/drivers/net/e1000e/82571.c
index dc4eb87309c5..712ccc66ba25 100644
--- a/drivers/net/e1000e/82571.c
+++ b/drivers/net/e1000e/82571.c
@@ -267,8 +267,14 @@ static s32 e1000_init_mac_params_82571(struct e1000_adapter *adapter)
         }
 
         switch (hw->mac.type) {
+        case e1000_82573:
+                func->set_lan_id = e1000_set_lan_id_single_port;
+                func->check_mng_mode = e1000e_check_mng_mode_generic;
+                func->led_on = e1000e_led_on_generic;
+                break;
         case e1000_82574:
         case e1000_82583:
+                func->set_lan_id = e1000_set_lan_id_single_port;
                 func->check_mng_mode = e1000_check_mng_mode_82574;
                 func->led_on = e1000_led_on_82574;
                 break;
@@ -922,9 +928,12 @@ static s32 e1000_reset_hw_82571(struct e1000_hw *hw)
         ew32(IMC, 0xffffffff);
         icr = er32(ICR);
 
-        if (hw->mac.type == e1000_82571 &&
-                hw->dev_spec.e82571.alt_mac_addr_is_present)
-                        e1000e_set_laa_state_82571(hw, true);
+        /* Install any alternate MAC address into RAR0 */
+        ret_val = e1000_check_alt_mac_addr_generic(hw);
+        if (ret_val)
+                return ret_val;
+
+        e1000e_set_laa_state_82571(hw, true);
 
         /* Reinitialize the 82571 serdes link state machine */
         if (hw->phy.media_type == e1000_media_type_internal_serdes)
@@ -1225,32 +1234,6 @@ static s32 e1000_led_on_82574(struct e1000_hw *hw)
 }
 
 /**
- *  e1000_update_mc_addr_list_82571 - 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.
- **/
-static void e1000_update_mc_addr_list_82571(struct e1000_hw *hw,
-                                            u8 *mc_addr_list,
-                                            u32 mc_addr_count,
-                                            u32 rar_used_count,
-                                            u32 rar_count)
-{
-        if (e1000e_get_laa_state_82571(hw))
-                rar_count--;
-
-        e1000e_update_mc_addr_list_generic(hw, mc_addr_list, mc_addr_count,
-                                           rar_used_count, rar_count);
-}
-
-/**
  *  e1000_setup_link_82571 - Setup flow control and link settings
  *  @hw: pointer to the HW structure
  *
@@ -1621,6 +1604,29 @@ static s32 e1000_fix_nvm_checksum_82571(struct e1000_hw *hw)
 }
 
 /**
+ *  e1000_read_mac_addr_82571 - Read device MAC address
+ *  @hw: pointer to the HW structure
+ **/
+static s32 e1000_read_mac_addr_82571(struct e1000_hw *hw)
+{
+        s32 ret_val = 0;
+
+        /*
+         * If there's an alternate MAC address place it in RAR0
+         * so that it will override the Si installed default perm
+         * address.
+         */
+        ret_val = e1000_check_alt_mac_addr_generic(hw);
+        if (ret_val)
+                goto out;
+
+        ret_val = e1000_read_mac_addr_generic(hw);
+
+out:
+        return ret_val;
+}
+
+/**
  * e1000_power_down_phy_copper_82571 - Remove link during PHY power down
  * @hw: pointer to the HW structure
  *
@@ -1695,10 +1701,11 @@ static struct e1000_mac_operations e82571_mac_ops = {
         .cleanup_led            = e1000e_cleanup_led_generic,
         .clear_hw_cntrs         = e1000_clear_hw_cntrs_82571,
         .get_bus_info           = e1000e_get_bus_info_pcie,
+        .set_lan_id             = e1000_set_lan_id_multi_port_pcie,
         /* .get_link_up_info: media type dependent */
         /* .led_on: mac type dependent */
         .led_off                = e1000e_led_off_generic,
-        .update_mc_addr_list    = e1000_update_mc_addr_list_82571,
+        .update_mc_addr_list    = e1000e_update_mc_addr_list_generic,
         .write_vfta             = e1000_write_vfta_generic,
         .clear_vfta             = e1000_clear_vfta_82571,
         .reset_hw               = e1000_reset_hw_82571,
@@ -1706,6 +1713,7 @@ static struct e1000_mac_operations e82571_mac_ops = {
         .setup_link             = e1000_setup_link_82571,
         /* .setup_physical_interface: media type dependent */
         .setup_led              = e1000e_setup_led_generic,
+        .read_mac_addr          = e1000_read_mac_addr_82571,
 };
 
 static struct e1000_phy_operations e82_phy_ops_igp = {
diff --git a/drivers/net/e1000e/defines.h b/drivers/net/e1000e/defines.h
index e02e38221ed4..db05ec355749 100644
--- a/drivers/net/e1000e/defines.h
+++ b/drivers/net/e1000e/defines.h
@@ -460,6 +460,8 @@
  */
 #define E1000_RAR_ENTRIES     15
 #define E1000_RAH_AV  0x80000000        /* Receive descriptor valid */
+#define E1000_RAL_MAC_ADDR_LEN 4
+#define E1000_RAH_MAC_ADDR_LEN 2
 
 /* Error Codes */
 #define E1000_ERR_NVM      1
diff --git a/drivers/net/e1000e/e1000.h b/drivers/net/e1000e/e1000.h
index d236efaf7478..c2ec095d2163 100644
--- a/drivers/net/e1000e/e1000.h
+++ b/drivers/net/e1000e/e1000.h
@@ -459,7 +459,7 @@ extern int e1000e_setup_tx_resources(struct e1000_adapter *adapter);
 extern void e1000e_free_rx_resources(struct e1000_adapter *adapter);
 extern void e1000e_free_tx_resources(struct e1000_adapter *adapter);
 extern void e1000e_update_stats(struct e1000_adapter *adapter);
-extern bool e1000_has_link(struct e1000_adapter *adapter);
+extern bool e1000e_has_link(struct e1000_adapter *adapter);
 extern void e1000e_set_interrupt_capability(struct e1000_adapter *adapter);
 extern void e1000e_reset_interrupt_capability(struct e1000_adapter *adapter);
 
@@ -503,6 +503,8 @@ extern s32 e1000e_cleanup_led_generic(struct e1000_hw *hw);
 extern s32 e1000e_led_on_generic(struct e1000_hw *hw);
 extern s32 e1000e_led_off_generic(struct e1000_hw *hw);
 extern s32 e1000e_get_bus_info_pcie(struct e1000_hw *hw);
+extern void e1000_set_lan_id_multi_port_pcie(struct e1000_hw *hw);
+extern void e1000_set_lan_id_single_port(struct e1000_hw *hw);
 extern s32 e1000e_get_speed_and_duplex_copper(struct e1000_hw *hw, u16 *speed, u16 *duplex);
 extern s32 e1000e_get_speed_and_duplex_fiber_serdes(struct e1000_hw *hw, u16 *speed, u16 *duplex);
 extern s32 e1000e_disable_pcie_master(struct e1000_hw *hw);
@@ -517,9 +519,7 @@ extern void e1000_clear_vfta_generic(struct e1000_hw *hw);
 extern void e1000e_init_rx_addrs(struct e1000_hw *hw, u16 rar_count);
 extern void e1000e_update_mc_addr_list_generic(struct e1000_hw *hw,
                                                u8 *mc_addr_list,
-                                               u32 mc_addr_count,
-                                               u32 rar_used_count,
-                                               u32 rar_count);
+                                               u32 mc_addr_count);
 extern void e1000e_rar_set(struct e1000_hw *hw, u8 *addr, u32 index);
 extern s32 e1000e_set_fc_watermarks(struct e1000_hw *hw);
 extern void e1000e_set_pcie_no_snoop(struct e1000_hw *hw, u32 no_snoop);
@@ -530,6 +530,7 @@ extern s32 e1000e_config_fc_after_link_up(struct e1000_hw *hw);
 extern s32 e1000e_force_mac_fc(struct e1000_hw *hw);
 extern s32 e1000e_blink_led(struct e1000_hw *hw);
 extern void e1000_write_vfta_generic(struct e1000_hw *hw, u32 offset, u32 value);
+extern s32 e1000_check_alt_mac_addr_generic(struct e1000_hw *hw);
 extern void e1000e_reset_adaptive(struct e1000_hw *hw);
 extern void e1000e_update_adaptive(struct e1000_hw *hw);
 
@@ -629,7 +630,15 @@ extern s32 e1000e_read_nvm_eerd(struct e1000_hw *hw, u16 offset, u16 words, u16
 extern s32 e1000e_validate_nvm_checksum_generic(struct e1000_hw *hw);
 extern void e1000e_release_nvm(struct e1000_hw *hw);
 extern void e1000e_reload_nvm(struct e1000_hw *hw);
-extern s32 e1000e_read_mac_addr(struct e1000_hw *hw);
+extern s32 e1000_read_mac_addr_generic(struct e1000_hw *hw);
+
+static inline s32 e1000e_read_mac_addr(struct e1000_hw *hw)
+{
+        if (hw->mac.ops.read_mac_addr)
+                return hw->mac.ops.read_mac_addr(hw);
+
+        return e1000_read_mac_addr_generic(hw);
+}
 
 static inline s32 e1000_validate_nvm_checksum(struct e1000_hw *hw)
 {
diff --git a/drivers/net/e1000e/es2lan.c b/drivers/net/e1000e/es2lan.c
index e2aa3b788564..27d21589a69a 100644
--- a/drivers/net/e1000e/es2lan.c
+++ b/drivers/net/e1000e/es2lan.c
@@ -246,6 +246,9 @@ static s32 e1000_init_mac_params_80003es2lan(struct e1000_adapter *adapter)
                 break;
         }
 
+        /* set lan id for port to determine which phy lock to use */
+        hw->mac.ops.set_lan_id(hw);
+
         return 0;
 }
 
@@ -814,7 +817,9 @@ static s32 e1000_reset_hw_80003es2lan(struct e1000_hw *hw)
         ew32(IMC, 0xffffffff);
         icr = er32(ICR);
 
-        return 0;
+        ret_val = e1000_check_alt_mac_addr_generic(hw);
+
+        return ret_val;
 }
 
 /**
@@ -1340,6 +1345,29 @@ static s32 e1000_write_kmrn_reg_80003es2lan(struct e1000_hw *hw, u32 offset,
 }
 
 /**
+ *  e1000_read_mac_addr_80003es2lan - Read device MAC address
+ *  @hw: pointer to the HW structure
+ **/
+static s32 e1000_read_mac_addr_80003es2lan(struct e1000_hw *hw)
+{
+        s32 ret_val = 0;
+
+        /*
+         * If there's an alternate MAC address place it in RAR0
+         * so that it will override the Si installed default perm
+         * address.
+         */
+        ret_val = e1000_check_alt_mac_addr_generic(hw);
+        if (ret_val)
+                goto out;
+
+        ret_val = e1000_read_mac_addr_generic(hw);
+
+out:
+        return ret_val;
+}
+
+/**
  * e1000_power_down_phy_copper_80003es2lan - Remove link during PHY power down
  * @hw: pointer to the HW structure
  *
@@ -1403,12 +1431,14 @@ static void e1000_clear_hw_cntrs_80003es2lan(struct e1000_hw *hw)
 }
 
 static struct e1000_mac_operations es2_mac_ops = {
+        .read_mac_addr          = e1000_read_mac_addr_80003es2lan,
         .id_led_init            = e1000e_id_led_init,
         .check_mng_mode         = e1000e_check_mng_mode_generic,
         /* check_for_link dependent on media type */
         .cleanup_led            = e1000e_cleanup_led_generic,
         .clear_hw_cntrs         = e1000_clear_hw_cntrs_80003es2lan,
         .get_bus_info           = e1000e_get_bus_info_pcie,
+        .set_lan_id             = e1000_set_lan_id_multi_port_pcie,
         .get_link_up_info       = e1000_get_link_up_info_80003es2lan,
         .led_on                 = e1000e_led_on_generic,
         .led_off                = e1000e_led_off_generic,
diff --git a/drivers/net/e1000e/ethtool.c b/drivers/net/e1000e/ethtool.c
index 0aa50c229c79..b33e3cbe9ab0 100644
--- a/drivers/net/e1000e/ethtool.c
+++ b/drivers/net/e1000e/ethtool.c
@@ -202,7 +202,7 @@ static u32 e1000_get_link(struct net_device *netdev)
         if (!netif_carrier_ok(netdev))
                 mac->get_link_status = 1;
 
-        return e1000_has_link(adapter);
+        return e1000e_has_link(adapter);
 }
 
 static int e1000_set_spd_dplx(struct e1000_adapter *adapter, u16 spddplx)
diff --git a/drivers/net/e1000e/hw.h b/drivers/net/e1000e/hw.h
index eccf29b75c41..8bdcd5f24eff 100644
--- a/drivers/net/e1000e/hw.h
+++ b/drivers/net/e1000e/hw.h
@@ -389,6 +389,9 @@ enum e1e_registers {
 
 #define E1000_FUNC_1 1
 
+#define E1000_ALT_MAC_ADDRESS_OFFSET_LAN0   0
+#define E1000_ALT_MAC_ADDRESS_OFFSET_LAN1   3
+
 enum e1000_mac_type {
         e1000_82571,
         e1000_82572,
@@ -746,16 +749,18 @@ struct e1000_mac_operations {
         void (*clear_hw_cntrs)(struct e1000_hw *);
         void (*clear_vfta)(struct e1000_hw *);
         s32  (*get_bus_info)(struct e1000_hw *);
+        void (*set_lan_id)(struct e1000_hw *);
         s32  (*get_link_up_info)(struct e1000_hw *, u16 *, u16 *);
         s32  (*led_on)(struct e1000_hw *);
         s32  (*led_off)(struct e1000_hw *);
-        void (*update_mc_addr_list)(struct e1000_hw *, u8 *, u32, u32, u32);
+        void (*update_mc_addr_list)(struct e1000_hw *, u8 *, u32);
         s32  (*reset_hw)(struct e1000_hw *);
         s32  (*init_hw)(struct e1000_hw *);
         s32  (*setup_link)(struct e1000_hw *);
         s32  (*setup_physical_interface)(struct e1000_hw *);
         s32  (*setup_led)(struct e1000_hw *);
         void (*write_vfta)(struct e1000_hw *, u32, u32);
+        s32  (*read_mac_addr)(struct e1000_hw *);
 };
 
 /* Function pointers for the PHY. */
@@ -814,6 +819,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;
@@ -897,7 +906,6 @@ struct e1000_fc_info {
 
 struct e1000_dev_spec_82571 {
         bool laa_is_present;
-        bool alt_mac_addr_is_present;
         u32 smb_counter;
 };
 
diff --git a/drivers/net/e1000e/ich8lan.c b/drivers/net/e1000e/ich8lan.c
index 8b6ecd127889..54d03a0ce3ce 100644
--- a/drivers/net/e1000e/ich8lan.c
+++ b/drivers/net/e1000e/ich8lan.c
@@ -3368,6 +3368,7 @@ static struct e1000_mac_operations ich8_mac_ops = {
         /* cleanup_led dependent on mac type */
         .clear_hw_cntrs         = e1000_clear_hw_cntrs_ich8lan,
         .get_bus_info           = e1000_get_bus_info_ich8lan,
+        .set_lan_id             = e1000_set_lan_id_single_port,
         .get_link_up_info       = e1000_get_link_up_info_ich8lan,
         /* led_on dependent on mac type */
         /* led_off dependent on mac type */
diff --git a/drivers/net/e1000e/lib.c b/drivers/net/e1000e/lib.c
index 3af0b1b82832..a8b2c0de27c4 100644
--- a/drivers/net/e1000e/lib.c
+++ b/drivers/net/e1000e/lib.c
@@ -51,10 +51,10 @@ enum e1000_mng_mode {
  **/
 s32 e1000e_get_bus_info_pcie(struct e1000_hw *hw)
 {
+        struct e1000_mac_info *mac = &hw->mac;
         struct e1000_bus_info *bus = &hw->bus;
         struct e1000_adapter *adapter = hw->adapter;
-        u32 status;
-        u16 pcie_link_status, pci_header_type, cap_offset;
+        u16 pcie_link_status, cap_offset;
 
         cap_offset = pci_find_capability(adapter->pdev, PCI_CAP_ID_EXP);
         if (!cap_offset) {
@@ -68,20 +68,46 @@ s32 e1000e_get_bus_info_pcie(struct e1000_hw *hw)
                                                     PCIE_LINK_WIDTH_SHIFT);
         }
 
-        pci_read_config_word(adapter->pdev, PCI_HEADER_TYPE_REGISTER,
-                             &pci_header_type);
-        if (pci_header_type & PCI_HEADER_TYPE_MULTIFUNC) {
-                status = er32(STATUS);
-                bus->func = (status & E1000_STATUS_FUNC_MASK)
-                            >> E1000_STATUS_FUNC_SHIFT;
-        } else {
-                bus->func = 0;
-        }
+        mac->ops.set_lan_id(hw);
 
         return 0;
 }
 
 /**
+ *  e1000_set_lan_id_multi_port_pcie - Set LAN id for PCIe multiple port devices
+ *
+ *  @hw: pointer to the HW structure
+ *
+ *  Determines the LAN function id by reading memory-mapped registers
+ *  and swaps the port value if requested.
+ **/
+void e1000_set_lan_id_multi_port_pcie(struct e1000_hw *hw)
+{
+        struct e1000_bus_info *bus = &hw->bus;
+        u32 reg;
+
+        /*
+         * The status register reports the correct function number
+         * for the device regardless of function swap state.
+         */
+        reg = er32(STATUS);
+        bus->func = (reg & E1000_STATUS_FUNC_MASK) >> E1000_STATUS_FUNC_SHIFT;
+}
+
+/**
+ *  e1000_set_lan_id_single_port - Set LAN id for a single port device
+ *  @hw: pointer to the HW structure
+ *
+ *  Sets the LAN function id to zero for a single port device.
+ **/
+void e1000_set_lan_id_single_port(struct e1000_hw *hw)
+{
+        struct e1000_bus_info *bus = &hw->bus;
+
+        bus->func = 0;
+}
+
+/**
  *  e1000_clear_vfta_generic - Clear VLAN filter table
  *  @hw: pointer to the HW structure
  *
@@ -139,6 +165,68 @@ void e1000e_init_rx_addrs(struct e1000_hw *hw, u16 rar_count)
 }
 
 /**
+ *  e1000_check_alt_mac_addr_generic - Check for alternate MAC addr
+ *  @hw: pointer to the HW structure
+ *
+ *  Checks the nvm for an alternate MAC address.  An alternate MAC address
+ *  can be setup by pre-boot software and must be treated like a permanent
+ *  address and must override the actual permanent MAC address. If an
+ *  alternate MAC address is found it is programmed into RAR0, replacing
+ *  the permanent address that was installed into RAR0 by the Si on reset.
+ *  This function will return SUCCESS unless it encounters an error while
+ *  reading the EEPROM.
+ **/
+s32 e1000_check_alt_mac_addr_generic(struct e1000_hw *hw)
+{
+        u32 i;
+        s32 ret_val = 0;
+        u16 offset, nvm_alt_mac_addr_offset, nvm_data;
+        u8 alt_mac_addr[ETH_ALEN];
+
+        ret_val = e1000_read_nvm(hw, NVM_ALT_MAC_ADDR_PTR, 1,
+                                 &nvm_alt_mac_addr_offset);
+        if (ret_val) {
+                e_dbg("NVM Read Error\n");
+                goto out;
+        }
+
+        if (nvm_alt_mac_addr_offset == 0xFFFF) {
+                /* There is no Alternate MAC Address */
+                goto out;
+        }
+
+        if (hw->bus.func == E1000_FUNC_1)
+                nvm_alt_mac_addr_offset += E1000_ALT_MAC_ADDRESS_OFFSET_LAN1;
+        for (i = 0; i < ETH_ALEN; i += 2) {
+                offset = nvm_alt_mac_addr_offset + (i >> 1);
+                ret_val = e1000_read_nvm(hw, offset, 1, &nvm_data);
+                if (ret_val) {
+                        e_dbg("NVM Read Error\n");
+                        goto out;
+                }
+
+                alt_mac_addr[i] = (u8)(nvm_data & 0xFF);
+                alt_mac_addr[i + 1] = (u8)(nvm_data >> 8);
+        }
+
+        /* if multicast bit is set, the alternate address will not be used */
+        if (alt_mac_addr[0] & 0x01) {
+                e_dbg("Ignoring Alternate Mac Address with MC bit set\n");
+                goto out;
+        }
+
+        /*
+         * We have a valid alternate MAC address, and we want to treat it the
+         * same as the normal permanent MAC address stored by the HW into the
+         * RAR. Do this by mapping this address into RAR0.
+         */
+        e1000e_rar_set(hw, alt_mac_addr, 0);
+
+out:
+        return ret_val;
+}
+
+/**
  *  e1000e_rar_set - Set receive address register
  *  @hw: pointer to the HW structure
  *  @addr: pointer to the receive address
@@ -252,62 +340,34 @@ static u32 e1000_hash_mc_addr(struct e1000_hw *hw, u8 *mc_addr)
  *  @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.
+ *  Updates entire 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 e1000e_update_mc_addr_list_generic(struct e1000_hw *hw,
-                                        u8 *mc_addr_list, u32 mc_addr_count,
-                                        u32 rar_used_count, u32 rar_count)
+                                        u8 *mc_addr_list, u32 mc_addr_count)
 {
-        u32 i;
-        u32 *mcarray = kzalloc(hw->mac.mta_reg_count * sizeof(u32), GFP_ATOMIC);
+        u32 hash_value, hash_bit, hash_reg;
+        int i;
 
-        if (!mcarray) {
-                printk(KERN_ERR "multicast array memory allocation failed\n");
-                return;
-        }
+        /* clear mta_shadow */
+        memset(&hw->mac.mta_shadow, 0, sizeof(hw->mac.mta_shadow));
 
-        /*
-         * 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) {
-                        e1000e_rar_set(hw, mc_addr_list, i);
-                        mc_addr_count--;
-                        mc_addr_list += ETH_ALEN;
-                } else {
-                        E1000_WRITE_REG_ARRAY(hw, E1000_RA, i << 1, 0);
-                        e1e_flush();
-                        E1000_WRITE_REG_ARRAY(hw, E1000_RA, (i << 1) + 1, 0);
-                        e1e_flush();
-                }
-        }
-
-        /* Load any remaining multicast addresses into the hash table. */
-        for (; mc_addr_count > 0; mc_addr_count--) {
-                u32 hash_value, hash_reg, hash_bit, mta;
+        /* update mta_shadow from mc_addr_list */
+        for (i = 0; (u32) i < mc_addr_count; i++) {
                 hash_value = e1000_hash_mc_addr(hw, mc_addr_list);
-                e_dbg("Hash value = 0x%03X\n", hash_value);
+
                 hash_reg = (hash_value >> 5) & (hw->mac.mta_reg_count - 1);
                 hash_bit = hash_value & 0x1F;
-                mta = (1 << hash_bit);
-                mcarray[hash_reg] |= mta;
-                mc_addr_list += ETH_ALEN;
-        }
 
-        /* write the hash table completely */
-        for (i = 0; i < hw->mac.mta_reg_count; i++)
-                E1000_WRITE_REG_ARRAY(hw, E1000_MTA, i, mcarray[i]);
+                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--)
+                E1000_WRITE_REG_ARRAY(hw, E1000_MTA, i, hw->mac.mta_shadow[i]);
         e1e_flush();
-        kfree(mcarray);
 }
 
 /**
@@ -2072,67 +2132,27 @@ s32 e1000e_write_nvm_spi(struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
 }
 
 /**
- *  e1000e_read_mac_addr - Read device MAC address
+ *  e1000_read_mac_addr_generic - Read device MAC address
  *  @hw: pointer to the HW structure
  *
  *  Reads the device MAC address from the EEPROM and stores the value.
  *  Since devices with two ports use the same EEPROM, we increment the
  *  last bit in the MAC address for the second port.
  **/
-s32 e1000e_read_mac_addr(struct e1000_hw *hw)
+s32 e1000_read_mac_addr_generic(struct e1000_hw *hw)
 {
-        s32 ret_val;
-        u16 offset, nvm_data, i;
-        u16 mac_addr_offset = 0;
-
-        if (hw->mac.type == e1000_82571) {
-                /* Check for an alternate MAC address.  An alternate MAC
-                 * address can be setup by pre-boot software and must be
-                 * treated like a permanent address and must override the
-                 * actual permanent MAC address.*/
-                ret_val = e1000_read_nvm(hw, NVM_ALT_MAC_ADDR_PTR, 1,
-                                         &mac_addr_offset);
-                if (ret_val) {
-                        e_dbg("NVM Read Error\n");
-                        return ret_val;
-                }
-                if (mac_addr_offset == 0xFFFF)
-                        mac_addr_offset = 0;
-
-                if (mac_addr_offset) {
-                        if (hw->bus.func == E1000_FUNC_1)
-                                mac_addr_offset += ETH_ALEN/sizeof(u16);
-
-                        /* make sure we have a valid mac address here
-                        * before using it */
-                        ret_val = e1000_read_nvm(hw, mac_addr_offset, 1,
-                                                 &nvm_data);
-                        if (ret_val) {
-                                e_dbg("NVM Read Error\n");
-                                return ret_val;
-                        }
-                        if (nvm_data & 0x0001)
-                                mac_addr_offset = 0;
-                }
+        u32 rar_high;
+        u32 rar_low;
+        u16 i;
 
-                if (mac_addr_offset)
-                hw->dev_spec.e82571.alt_mac_addr_is_present = 1;
-        }
+        rar_high = er32(RAH(0));
+        rar_low = er32(RAL(0));
 
-        for (i = 0; i < ETH_ALEN; i += 2) {
-                offset = mac_addr_offset + (i >> 1);
-                ret_val = e1000_read_nvm(hw, offset, 1, &nvm_data);
-                if (ret_val) {
-                        e_dbg("NVM Read Error\n");
-                        return ret_val;
-                }
-                hw->mac.perm_addr[i] = (u8)(nvm_data & 0xFF);
-                hw->mac.perm_addr[i+1] = (u8)(nvm_data >> 8);
-        }
+        for (i = 0; i < E1000_RAL_MAC_ADDR_LEN; i++)
+                hw->mac.perm_addr[i] = (u8)(rar_low >> (i*8));
 
-        /* Flip last bit of mac address if we're on second port */
-        if (!mac_addr_offset && hw->bus.func == E1000_FUNC_1)
-                hw->mac.perm_addr[5] ^= 1;
+        for (i = 0; i < E1000_RAH_MAC_ADDR_LEN; i++)
+                hw->mac.perm_addr[i+4] = (u8)(rar_high >> (i*8));
 
         for (i = 0; i < ETH_ALEN; i++)
                 hw->mac.addr[i] = hw->mac.perm_addr[i];
diff --git a/drivers/net/e1000e/netdev.c b/drivers/net/e1000e/netdev.c
index 57f149b75fbe..88d54d3efcef 100644
--- a/drivers/net/e1000e/netdev.c
+++ b/drivers/net/e1000e/netdev.c
@@ -2541,22 +2541,14 @@ static void e1000_configure_rx(struct e1000_adapter *adapter)
  *  @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.
+ *  Updates the 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.  Currently no func pointer
- *  exists and all implementations are handled in the generic version of this
- *  function.
  **/
 static void e1000_update_mc_addr_list(struct e1000_hw *hw, u8 *mc_addr_list,
-                                      u32 mc_addr_count, u32 rar_used_count,
-                                      u32 rar_count)
+                                      u32 mc_addr_count)
 {
-        hw->mac.ops.update_mc_addr_list(hw, mc_addr_list, mc_addr_count,
-                                        rar_used_count, rar_count);
+        hw->mac.ops.update_mc_addr_list(hw, mc_addr_list, mc_addr_count);
 }
 
 /**
@@ -2572,7 +2564,6 @@ static void e1000_set_multi(struct net_device *netdev)
 {
         struct e1000_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;
         u32 rctl;
@@ -2598,31 +2589,25 @@ static void e1000_set_multi(struct net_device *netdev)
 
         ew32(RCTL, rctl);
 
-        if (netdev->mc_count) {
-                mta_list = kmalloc(netdev->mc_count * 6, GFP_ATOMIC);
+        if (!netdev_mc_empty(netdev)) {
+                mta_list = kmalloc(netdev_mc_count(netdev) * 6, GFP_ATOMIC);
                 if (!mta_list)
                         return;
 
                 /* prepare a packed array of only addresses. */
-                mc_ptr = netdev->mc_list;
-
-                for (i = 0; i < netdev->mc_count; i++) {
-                        if (!mc_ptr)
-                                break;
-                        memcpy(mta_list + (i*ETH_ALEN), mc_ptr->dmi_addr,
-                               ETH_ALEN);
-                        mc_ptr = mc_ptr->next;
-                }
+                i = 0;
+                netdev_for_each_mc_addr(mc_ptr, netdev)
+                        memcpy(mta_list + (i++ * ETH_ALEN),
+                               mc_ptr->dmi_addr, ETH_ALEN);
 
-                e1000_update_mc_addr_list(hw, mta_list, i, 1,
-                                          mac->rar_entry_count);
+                e1000_update_mc_addr_list(hw, mta_list, i);
                 kfree(mta_list);
         } else {
                 /*
                  * if we're called from probe, we might not have
                  * anything to do here, so clear out the list
                  */
-                e1000_update_mc_addr_list(hw, NULL, 0, 1, mac->rar_entry_count);
+                e1000_update_mc_addr_list(hw, NULL, 0);
         }
 }
 
@@ -3482,7 +3467,7 @@ static void e1000_print_link_info(struct e1000_adapter *adapter)
                ((ctrl & E1000_CTRL_TFCE) ? "TX" : "None" )));
 }
 
-bool e1000_has_link(struct e1000_adapter *adapter)
+bool e1000e_has_link(struct e1000_adapter *adapter)
 {
         struct e1000_hw *hw = &adapter->hw;
         bool link_active = 0;
@@ -3563,7 +3548,7 @@ static void e1000_watchdog_task(struct work_struct *work)
         u32 link, tctl;
         int tx_pending = 0;
 
-        link = e1000_has_link(adapter);
+        link = e1000e_has_link(adapter);
         if ((netif_carrier_ok(netdev)) && link) {
                 e1000e_enable_receives(adapter);
                 goto link_up;
@@ -5134,7 +5119,7 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
 
         e1000_eeprom_checks(adapter);
 
-        /* copy the MAC address out of the NVM */
+        /* copy the MAC address */
         if (e1000e_read_mac_addr(&adapter->hw))
                 e_err("NVM Read Error while reading MAC address\n");
 
@@ -5326,7 +5311,7 @@ static struct pci_error_handlers e1000_err_handler = {
         .resume = e1000_io_resume,
 };
 
-static struct pci_device_id e1000_pci_tbl[] = {
+static DEFINE_PCI_DEVICE_TABLE(e1000_pci_tbl) = {
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_COPPER), board_82571 },
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_FIBER), board_82571 },
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_QUAD_COPPER), board_82571 },