Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next-2.6

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next-2.6: (1480 commits)
  bonding: enable netpoll without checking link status
  xfrm: Refcount destination entry on xfrm_lookup
  net: introduce rx_handler results and logic around that
  bonding: get rid of IFF_SLAVE_INACTIVE netdev->priv_flag
  bonding: wrap slave state work
  net: get rid of multiple bond-related netdevice->priv_flags
  bonding: register slave pointer for rx_handler
  be2net: Bump up the version number
  be2net: Copyright notice change. Update to Emulex instead of ServerEngines
  e1000e: fix kconfig for crc32 dependency
  netfilter ebtables: fix xt_AUDIT to work with ebtables
  xen network backend driver
  bonding: Improve syslog message at device creation time
  bonding: Call netif_carrier_off after register_netdevice
  bonding: Incorrect TX queue offset
  net_sched: fix ip_tos2prio
  xfrm: fix __xfrm_route_forward()
  be2net: Fix UDP packet detected status in RX compl
  Phonet: fix aligned-mode pipe socket buffer header reserve
  netxen: support for GbE port settings
  ...

Fix up conflicts in drivers/staging/brcm80211/brcmsmac/wl_mac80211.c
with the staging updates.

8 files changed, 180 insertions, 112 deletions

diff --git a/drivers/net/e1000e/defines.h b/drivers/net/e1000e/defines.h
index 13149983d07e..c516a7440bec 100644
--- a/drivers/net/e1000e/defines.h
+++ b/drivers/net/e1000e/defines.h
@@ -86,6 +86,7 @@
 #define E1000_CTRL_EXT_IAME           0x08000000 /* Interrupt acknowledge Auto-mask */
 #define E1000_CTRL_EXT_INT_TIMER_CLR  0x20000000 /* Clear Interrupt timers after IMS clear */
 #define E1000_CTRL_EXT_PBA_CLR        0x80000000 /* PBA Clear */
+#define E1000_CTRL_EXT_LSECCK         0x00001000
 #define E1000_CTRL_EXT_PHYPDEN        0x00100000
 
 /* Receive Descriptor bit definitions */
diff --git a/drivers/net/e1000e/e1000.h b/drivers/net/e1000e/e1000.h
index e610e1369053..00bf595ebd67 100644
--- a/drivers/net/e1000e/e1000.h
+++ b/drivers/net/e1000e/e1000.h
@@ -364,6 +364,7 @@ struct e1000_adapter {
         /* structs defined in e1000_hw.h */
         struct e1000_hw hw;
 
+        spinlock_t stats64_lock;
         struct e1000_hw_stats stats;
         struct e1000_phy_info phy_info;
         struct e1000_phy_stats phy_stats;
@@ -494,7 +495,9 @@ extern int e1000e_setup_rx_resources(struct e1000_adapter *adapter);
 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 struct rtnl_link_stats64 *e1000e_get_stats64(struct net_device *netdev,
+                                                    struct rtnl_link_stats64
+                                                    *stats);
 extern void e1000e_set_interrupt_capability(struct e1000_adapter *adapter);
 extern void e1000e_reset_interrupt_capability(struct e1000_adapter *adapter);
 extern void e1000e_get_hw_control(struct e1000_adapter *adapter);
diff --git a/drivers/net/e1000e/ethtool.c b/drivers/net/e1000e/ethtool.c
index fa08b6336cfb..07f09e96e453 100644
--- a/drivers/net/e1000e/ethtool.c
+++ b/drivers/net/e1000e/ethtool.c
@@ -46,15 +46,15 @@ struct e1000_stats {
 };
 
 #define E1000_STAT(str, m) { \
-                        .stat_string = str, \
-                        .type = E1000_STATS, \
-                        .sizeof_stat = sizeof(((struct e1000_adapter *)0)->m), \
-                        .stat_offset = offsetof(struct e1000_adapter, m) }
+                .stat_string = str, \
+                .type = E1000_STATS, \
+                .sizeof_stat = sizeof(((struct e1000_adapter *)0)->m), \
+                .stat_offset = offsetof(struct e1000_adapter, m) }
 #define E1000_NETDEV_STAT(str, m) { \
-                        .stat_string = str, \
-                        .type = NETDEV_STATS, \
-                        .sizeof_stat = sizeof(((struct net_device *)0)->m), \
-                        .stat_offset = offsetof(struct net_device, m) }
+                .stat_string = str, \
+                .type = NETDEV_STATS, \
+                .sizeof_stat = sizeof(((struct rtnl_link_stats64 *)0)->m), \
+                .stat_offset = offsetof(struct rtnl_link_stats64, m) }
 
 static const struct e1000_stats e1000_gstrings_stats[] = {
         E1000_STAT("rx_packets", stats.gprc),
@@ -65,21 +65,21 @@ static const struct e1000_stats e1000_gstrings_stats[] = {
         E1000_STAT("tx_broadcast", stats.bptc),
         E1000_STAT("rx_multicast", stats.mprc),
         E1000_STAT("tx_multicast", stats.mptc),
-        E1000_NETDEV_STAT("rx_errors", stats.rx_errors),
-        E1000_NETDEV_STAT("tx_errors", stats.tx_errors),
-        E1000_NETDEV_STAT("tx_dropped", stats.tx_dropped),
+        E1000_NETDEV_STAT("rx_errors", rx_errors),
+        E1000_NETDEV_STAT("tx_errors", tx_errors),
+        E1000_NETDEV_STAT("tx_dropped", tx_dropped),
         E1000_STAT("multicast", stats.mprc),
         E1000_STAT("collisions", stats.colc),
-        E1000_NETDEV_STAT("rx_length_errors", stats.rx_length_errors),
-        E1000_NETDEV_STAT("rx_over_errors", stats.rx_over_errors),
+        E1000_NETDEV_STAT("rx_length_errors", rx_length_errors),
+        E1000_NETDEV_STAT("rx_over_errors", rx_over_errors),
         E1000_STAT("rx_crc_errors", stats.crcerrs),
-        E1000_NETDEV_STAT("rx_frame_errors", stats.rx_frame_errors),
+        E1000_NETDEV_STAT("rx_frame_errors", rx_frame_errors),
         E1000_STAT("rx_no_buffer_count", stats.rnbc),
         E1000_STAT("rx_missed_errors", stats.mpc),
         E1000_STAT("tx_aborted_errors", stats.ecol),
         E1000_STAT("tx_carrier_errors", stats.tncrs),
-        E1000_NETDEV_STAT("tx_fifo_errors", stats.tx_fifo_errors),
-        E1000_NETDEV_STAT("tx_heartbeat_errors", stats.tx_heartbeat_errors),
+        E1000_NETDEV_STAT("tx_fifo_errors", tx_fifo_errors),
+        E1000_NETDEV_STAT("tx_heartbeat_errors", tx_heartbeat_errors),
         E1000_STAT("tx_window_errors", stats.latecol),
         E1000_STAT("tx_abort_late_coll", stats.latecol),
         E1000_STAT("tx_deferred_ok", stats.dc),
@@ -433,13 +433,11 @@ static void e1000_get_regs(struct net_device *netdev,
         struct e1000_hw *hw = &adapter->hw;
         u32 *regs_buff = p;
         u16 phy_data;
-        u8 revision_id;
 
         memset(p, 0, E1000_REGS_LEN * sizeof(u32));
 
-        pci_read_config_byte(adapter->pdev, PCI_REVISION_ID, &revision_id);
-
-        regs->version = (1 << 24) | (revision_id << 16) | adapter->pdev->device;
+        regs->version = (1 << 24) | (adapter->pdev->revision << 16) |
+                        adapter->pdev->device;
 
         regs_buff[0]  = er32(CTRL);
         regs_buff[1]  = er32(STATUS);
@@ -684,20 +682,13 @@ static int e1000_set_ringparam(struct net_device *netdev,
         rx_old = adapter->rx_ring;
 
         err = -ENOMEM;
-        tx_ring = kzalloc(sizeof(struct e1000_ring), GFP_KERNEL);
+        tx_ring = kmemdup(tx_old, sizeof(struct e1000_ring), GFP_KERNEL);
         if (!tx_ring)
                 goto err_alloc_tx;
-        /*
-         * use a memcpy to save any previously configured
-         * items like napi structs from having to be
-         * reinitialized
-         */
-        memcpy(tx_ring, tx_old, sizeof(struct e1000_ring));
 
-        rx_ring = kzalloc(sizeof(struct e1000_ring), GFP_KERNEL);
+        rx_ring = kmemdup(rx_old, sizeof(struct e1000_ring), GFP_KERNEL);
         if (!rx_ring)
                 goto err_alloc_rx;
-        memcpy(rx_ring, rx_old, sizeof(struct e1000_ring));
 
         adapter->tx_ring = tx_ring;
         adapter->rx_ring = rx_ring;
@@ -1255,7 +1246,6 @@ static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter)
 {
         struct e1000_hw *hw = &adapter->hw;
         u32 ctrl_reg = 0;
-        u32 stat_reg = 0;
         u16 phy_reg = 0;
         s32 ret_val = 0;
 
@@ -1363,8 +1353,7 @@ static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter)
                  * Set the ILOS bit on the fiber Nic if half duplex link is
                  * detected.
                  */
-                stat_reg = er32(STATUS);
-                if ((stat_reg & E1000_STATUS_FD) == 0)
+                if ((er32(STATUS) & E1000_STATUS_FD) == 0)
                         ctrl_reg |= (E1000_CTRL_ILOS | E1000_CTRL_SLU);
         }
 
@@ -1677,10 +1666,13 @@ static int e1000_link_test(struct e1000_adapter *adapter, u64 *data)
         } else {
                 hw->mac.ops.check_for_link(hw);
                 if (hw->mac.autoneg)
-                        msleep(4000);
+                        /*
+                         * On some Phy/switch combinations, link establishment
+                         * can take a few seconds more than expected.
+                         */
+                        msleep(5000);
 
-                if (!(er32(STATUS) &
-                      E1000_STATUS_LU))
+                if (!(er32(STATUS) & E1000_STATUS_LU))
                         *data = 1;
         }
         return *data;
@@ -1807,8 +1799,7 @@ static void e1000_get_wol(struct net_device *netdev,
                 return;
 
         wol->supported = WAKE_UCAST | WAKE_MCAST |
-                         WAKE_BCAST | WAKE_MAGIC |
-                         WAKE_PHY | WAKE_ARP;
+            WAKE_BCAST | WAKE_MAGIC | WAKE_PHY;
 
         /* apply any specific unsupported masks here */
         if (adapter->flags & FLAG_NO_WAKE_UCAST) {
@@ -1829,19 +1820,16 @@ static void e1000_get_wol(struct net_device *netdev,
                 wol->wolopts |= WAKE_MAGIC;
         if (adapter->wol & E1000_WUFC_LNKC)
                 wol->wolopts |= WAKE_PHY;
-        if (adapter->wol & E1000_WUFC_ARP)
-                wol->wolopts |= WAKE_ARP;
 }
 
-static int e1000_set_wol(struct net_device *netdev,
-                         struct ethtool_wolinfo *wol)
+static int e1000_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
 
         if (!(adapter->flags & FLAG_HAS_WOL) ||
             !device_can_wakeup(&adapter->pdev->dev) ||
             (wol->wolopts & ~(WAKE_UCAST | WAKE_MCAST | WAKE_BCAST |
-                              WAKE_MAGIC | WAKE_PHY | WAKE_ARP)))
+                              WAKE_MAGIC | WAKE_PHY)))
                 return -EOPNOTSUPP;
 
         /* these settings will always override what we currently have */
@@ -1857,8 +1845,6 @@ static int e1000_set_wol(struct net_device *netdev,
                 adapter->wol |= E1000_WUFC_MAG;
         if (wol->wolopts & WAKE_PHY)
                 adapter->wol |= E1000_WUFC_LNKC;
-        if (wol->wolopts & WAKE_ARP)
-                adapter->wol |= E1000_WUFC_ARP;
 
         device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
 
@@ -1972,8 +1958,15 @@ static int e1000_set_coalesce(struct net_device *netdev,
 static int e1000_nway_reset(struct net_device *netdev)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
-        if (netif_running(netdev))
-                e1000e_reinit_locked(adapter);
+
+        if (!netif_running(netdev))
+                return -EAGAIN;
+
+        if (!adapter->hw.mac.autoneg)
+                return -EINVAL;
+
+        e1000e_reinit_locked(adapter);
+
         return 0;
 }
 
@@ -1982,14 +1975,15 @@ static void e1000_get_ethtool_stats(struct net_device *netdev,
                                     u64 *data)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
+        struct rtnl_link_stats64 net_stats;
         int i;
         char *p = NULL;
 
-        e1000e_update_stats(adapter);
+        e1000e_get_stats64(netdev, &net_stats);
         for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) {
                 switch (e1000_gstrings_stats[i].type) {
                 case NETDEV_STATS:
-                        p = (char *) netdev +
+                        p = (char *) &net_stats +
                                         e1000_gstrings_stats[i].stat_offset;
                         break;
                 case E1000_STATS:
@@ -2014,7 +2008,7 @@ static void e1000_get_strings(struct net_device *netdev, u32 stringset,
 
         switch (stringset) {
         case ETH_SS_TEST:
-                memcpy(data, *e1000_gstrings_test, sizeof(e1000_gstrings_test));
+                memcpy(data, e1000_gstrings_test, sizeof(e1000_gstrings_test));
                 break;
         case ETH_SS_STATS:
                 for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) {
diff --git a/drivers/net/e1000e/hw.h b/drivers/net/e1000e/hw.h
index bc0860a598c9..307e1ec22417 100644
--- a/drivers/net/e1000e/hw.h
+++ b/drivers/net/e1000e/hw.h
@@ -812,9 +812,8 @@ struct e1000_nvm_operations {
 
 struct e1000_mac_info {
         struct e1000_mac_operations ops;
-
-        u8 addr[6];
-        u8 perm_addr[6];
+        u8 addr[ETH_ALEN];
+        u8 perm_addr[ETH_ALEN];
 
         enum e1000_mac_type type;
 
diff --git a/drivers/net/e1000e/ich8lan.c b/drivers/net/e1000e/ich8lan.c
index fb46974cfec1..ce1dbfdca112 100644
--- a/drivers/net/e1000e/ich8lan.c
+++ b/drivers/net/e1000e/ich8lan.c
@@ -140,6 +140,11 @@
 #define I82579_LPI_CTRL                 PHY_REG(772, 20)
 #define I82579_LPI_CTRL_ENABLE_MASK     0x6000
 
+/* EMI Registers */
+#define I82579_EMI_ADDR         0x10
+#define I82579_EMI_DATA         0x11
+#define I82579_LPI_UPDATE_TIMER 0x4805  /* in 40ns units + 40 ns base value */
+
 /* Strapping Option Register - RO */
 #define E1000_STRAP                     0x0000C
 #define E1000_STRAP_SMBUS_ADDRESS_MASK  0x00FE0000
@@ -302,9 +307,9 @@ static s32 e1000_init_phy_params_pchlan(struct e1000_hw *hw)
          * the interconnect to PCIe mode.
          */
         fwsm = er32(FWSM);
-        if (!(fwsm & E1000_ICH_FWSM_FW_VALID)) {
+        if (!(fwsm & E1000_ICH_FWSM_FW_VALID) && !e1000_check_reset_block(hw)) {
                 ctrl = er32(CTRL);
-                ctrl |=  E1000_CTRL_LANPHYPC_OVERRIDE;
+                ctrl |= E1000_CTRL_LANPHYPC_OVERRIDE;
                 ctrl &= ~E1000_CTRL_LANPHYPC_VALUE;
                 ew32(CTRL, ctrl);
                 udelay(10);
@@ -331,7 +336,7 @@ static s32 e1000_init_phy_params_pchlan(struct e1000_hw *hw)
                 goto out;
 
         /* Ungate automatic PHY configuration on non-managed 82579 */
-        if ((hw->mac.type == e1000_pch2lan)  &&
+        if ((hw->mac.type == e1000_pch2lan) &&
             !(fwsm & E1000_ICH_FWSM_FW_VALID)) {
                 msleep(10);
                 e1000_gate_hw_phy_config_ich8lan(hw, false);
@@ -366,7 +371,7 @@ static s32 e1000_init_phy_params_pchlan(struct e1000_hw *hw)
         case e1000_phy_82579:
                 phy->ops.check_polarity = e1000_check_polarity_82577;
                 phy->ops.force_speed_duplex =
-                        e1000_phy_force_speed_duplex_82577;
+                    e1000_phy_force_speed_duplex_82577;
                 phy->ops.get_cable_length = e1000_get_cable_length_82577;
                 phy->ops.get_info = e1000_get_phy_info_82577;
                 phy->ops.commit = e1000e_phy_sw_reset;
@@ -753,7 +758,13 @@ static s32 e1000_get_variants_ich8lan(struct e1000_adapter *adapter)
         if (rc)
                 return rc;
 
-        if (adapter->hw.phy.type == e1000_phy_ife) {
+        /*
+         * Disable Jumbo Frame support on parts with Intel 10/100 PHY or
+         * on parts with MACsec enabled in NVM (reflected in CTRL_EXT).
+         */
+        if ((adapter->hw.phy.type == e1000_phy_ife) ||
+            ((adapter->hw.mac.type >= e1000_pch2lan) &&
+             (!(er32(CTRL_EXT) & E1000_CTRL_EXT_LSECCK)))) {
                 adapter->flags &= ~FLAG_HAS_JUMBO_FRAMES;
                 adapter->max_hw_frame_size = ETH_FRAME_LEN + ETH_FCS_LEN;
         }
@@ -1723,11 +1734,25 @@ static s32 e1000_post_phy_reset_ich8lan(struct e1000_hw *hw)
         /* Configure the LCD with the OEM bits in NVM */
         ret_val = e1000_oem_bits_config_ich8lan(hw, true);
 
-        /* Ungate automatic PHY configuration on non-managed 82579 */
-        if ((hw->mac.type == e1000_pch2lan) &&
-            !(er32(FWSM) & E1000_ICH_FWSM_FW_VALID)) {
-                msleep(10);
-                e1000_gate_hw_phy_config_ich8lan(hw, false);
+        if (hw->mac.type == e1000_pch2lan) {
+                /* Ungate automatic PHY configuration on non-managed 82579 */
+                if (!(er32(FWSM) & E1000_ICH_FWSM_FW_VALID)) {
+                        msleep(10);
+                        e1000_gate_hw_phy_config_ich8lan(hw, false);
+                }
+
+                /* Set EEE LPI Update Timer to 200usec */
+                ret_val = hw->phy.ops.acquire(hw);
+                if (ret_val)
+                        goto out;
+                ret_val = hw->phy.ops.write_reg_locked(hw, I82579_EMI_ADDR,
+                                                       I82579_LPI_UPDATE_TIMER);
+                if (ret_val)
+                        goto release;
+                ret_val = hw->phy.ops.write_reg_locked(hw, I82579_EMI_DATA,
+                                                       0x1387);
+release:
+                hw->phy.ops.release(hw);
         }
 
 out:
@@ -2104,7 +2129,6 @@ static s32 e1000_flash_cycle_init_ich8lan(struct e1000_hw *hw)
 {
         union ich8_hws_flash_status hsfsts;
         s32 ret_val = -E1000_ERR_NVM;
-        s32 i = 0;
 
         hsfsts.regval = er16flash(ICH_FLASH_HSFSTS);
 
@@ -2140,6 +2164,8 @@ static s32 e1000_flash_cycle_init_ich8lan(struct e1000_hw *hw)
                 ew16flash(ICH_FLASH_HSFSTS, hsfsts.regval);
                 ret_val = 0;
         } else {
+                s32 i = 0;
+
                 /*
                  * Otherwise poll for sometime so the current
                  * cycle has a chance to end before giving up.
diff --git a/drivers/net/e1000e/lib.c b/drivers/net/e1000e/lib.c
index 68aa1749bf66..96921de5df2e 100644
--- a/drivers/net/e1000e/lib.c
+++ b/drivers/net/e1000e/lib.c
@@ -1978,15 +1978,15 @@ static s32 e1000_ready_nvm_eeprom(struct e1000_hw *hw)
 {
         struct e1000_nvm_info *nvm = &hw->nvm;
         u32 eecd = er32(EECD);
-        u16 timeout = 0;
         u8 spi_stat_reg;
 
         if (nvm->type == e1000_nvm_eeprom_spi) {
+                u16 timeout = NVM_MAX_RETRY_SPI;
+
                 /* Clear SK and CS */
                 eecd &= ~(E1000_EECD_CS | E1000_EECD_SK);
                 ew32(EECD, eecd);
                 udelay(1);
-                timeout = NVM_MAX_RETRY_SPI;
 
                 /*
                  * Read "Status Register" repeatedly until the LSB is cleared.
diff --git a/drivers/net/e1000e/netdev.c b/drivers/net/e1000e/netdev.c
index 6d513a383340..a39d4a4d871c 100644
--- a/drivers/net/e1000e/netdev.c
+++ b/drivers/net/e1000e/netdev.c
@@ -54,7 +54,7 @@
 
 #define DRV_EXTRAVERSION "-k2"
 
-#define DRV_VERSION "1.2.20" DRV_EXTRAVERSION
+#define DRV_VERSION "1.3.10" DRV_EXTRAVERSION
 char e1000e_driver_name[] = "e1000e";
 const char e1000e_driver_version[] = DRV_VERSION;
 
@@ -900,8 +900,6 @@ next_desc:
 
         adapter->total_rx_bytes += total_rx_bytes;
         adapter->total_rx_packets += total_rx_packets;
-        netdev->stats.rx_bytes += total_rx_bytes;
-        netdev->stats.rx_packets += total_rx_packets;
         return cleaned;
 }
 
@@ -1060,8 +1058,6 @@ static bool e1000_clean_tx_irq(struct e1000_adapter *adapter)
         }
         adapter->total_tx_bytes += total_tx_bytes;
         adapter->total_tx_packets += total_tx_packets;
-        netdev->stats.tx_bytes += total_tx_bytes;
-        netdev->stats.tx_packets += total_tx_packets;
         return count < tx_ring->count;
 }
 
@@ -1248,8 +1244,6 @@ next_desc:
 
         adapter->total_rx_bytes += total_rx_bytes;
         adapter->total_rx_packets += total_rx_packets;
-        netdev->stats.rx_bytes += total_rx_bytes;
-        netdev->stats.rx_packets += total_rx_packets;
         return cleaned;
 }
 
@@ -1328,7 +1322,7 @@ static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter,
                                 /* an error means any chain goes out the window
                                  * too */
                                 if (rx_ring->rx_skb_top)
-                                        dev_kfree_skb(rx_ring->rx_skb_top);
+                                        dev_kfree_skb_irq(rx_ring->rx_skb_top);
                                 rx_ring->rx_skb_top = NULL;
                                 goto next_desc;
                 }
@@ -1401,7 +1395,7 @@ static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter,
                 /* eth type trans needs skb->data to point to something */
                 if (!pskb_may_pull(skb, ETH_HLEN)) {
                         e_err("pskb_may_pull failed.\n");
-                        dev_kfree_skb(skb);
+                        dev_kfree_skb_irq(skb);
                         goto next_desc;
                 }
 
@@ -1429,8 +1423,6 @@ next_desc:
 
         adapter->total_rx_bytes += total_rx_bytes;
         adapter->total_rx_packets += total_rx_packets;
-        netdev->stats.rx_bytes += total_rx_bytes;
-        netdev->stats.rx_packets += total_rx_packets;
         return cleaned;
 }
 
@@ -1857,7 +1849,9 @@ static int e1000_request_msix(struct e1000_adapter *adapter)
         int err = 0, vector = 0;
 
         if (strlen(netdev->name) < (IFNAMSIZ - 5))
-                sprintf(adapter->rx_ring->name, "%s-rx-0", netdev->name);
+                snprintf(adapter->rx_ring->name,
+                         sizeof(adapter->rx_ring->name) - 1,
+                         "%s-rx-0", netdev->name);
         else
                 memcpy(adapter->rx_ring->name, netdev->name, IFNAMSIZ);
         err = request_irq(adapter->msix_entries[vector].vector,
@@ -1870,7 +1864,9 @@ static int e1000_request_msix(struct e1000_adapter *adapter)
         vector++;
 
         if (strlen(netdev->name) < (IFNAMSIZ - 5))
-                sprintf(adapter->tx_ring->name, "%s-tx-0", netdev->name);
+                snprintf(adapter->tx_ring->name,
+                         sizeof(adapter->tx_ring->name) - 1,
+                         "%s-tx-0", netdev->name);
         else
                 memcpy(adapter->tx_ring->name, netdev->name, IFNAMSIZ);
         err = request_irq(adapter->msix_entries[vector].vector,
@@ -2734,7 +2730,6 @@ static void e1000_setup_rctl(struct e1000_adapter *adapter)
 {
         struct e1000_hw *hw = &adapter->hw;
         u32 rctl, rfctl;
-        u32 psrctl = 0;
         u32 pages = 0;
 
         /* Workaround Si errata on 82579 - configure jumbo frame flow */
@@ -2833,6 +2828,8 @@ static void e1000_setup_rctl(struct e1000_adapter *adapter)
                 adapter->rx_ps_pages = 0;
 
         if (adapter->rx_ps_pages) {
+                u32 psrctl = 0;
+
                 /* Configure extra packet-split registers */
                 rfctl = er32(RFCTL);
                 rfctl |= E1000_RFCTL_EXTEN;
@@ -3034,7 +3031,6 @@ static void e1000_set_multi(struct net_device *netdev)
         struct netdev_hw_addr *ha;
         u8  *mta_list;
         u32 rctl;
-        int i;
 
         /* Check for Promiscuous and All Multicast modes */
 
@@ -3057,12 +3053,13 @@ static void e1000_set_multi(struct net_device *netdev)
         ew32(RCTL, rctl);
 
         if (!netdev_mc_empty(netdev)) {
+                int i = 0;
+
                 mta_list = kmalloc(netdev_mc_count(netdev) * 6, GFP_ATOMIC);
                 if (!mta_list)
                         return;
 
                 /* prepare a packed array of only addresses. */
-                i = 0;
                 netdev_for_each_mc_addr(ha, netdev)
                         memcpy(mta_list + (i++ * ETH_ALEN), ha->addr, ETH_ALEN);
 
@@ -3359,6 +3356,8 @@ static void e1000e_flush_descriptors(struct e1000_adapter *adapter)
         e1e_flush();
 }
 
+static void e1000e_update_stats(struct e1000_adapter *adapter);
+
 void e1000e_down(struct e1000_adapter *adapter)
 {
         struct net_device *netdev = adapter->netdev;
@@ -3393,6 +3392,11 @@ void e1000e_down(struct e1000_adapter *adapter)
         del_timer_sync(&adapter->phy_info_timer);
 
         netif_carrier_off(netdev);
+
+        spin_lock(&adapter->stats64_lock);
+        e1000e_update_stats(adapter);
+        spin_unlock(&adapter->stats64_lock);
+
         adapter->link_speed = 0;
         adapter->link_duplex = 0;
 
@@ -3437,6 +3441,8 @@ static int __devinit e1000_sw_init(struct e1000_adapter *adapter)
         adapter->max_frame_size = netdev->mtu + ETH_HLEN + ETH_FCS_LEN;
         adapter->min_frame_size = ETH_ZLEN + ETH_FCS_LEN;
 
+        spin_lock_init(&adapter->stats64_lock);
+
         e1000e_set_interrupt_capability(adapter);
 
         if (e1000_alloc_queues(adapter))
@@ -3918,7 +3924,7 @@ release:
  * e1000e_update_stats - Update the board statistics counters
  * @adapter: board private structure
  **/
-void e1000e_update_stats(struct e1000_adapter *adapter)
+static void e1000e_update_stats(struct e1000_adapter *adapter)
 {
         struct net_device *netdev = adapter->netdev;
         struct e1000_hw *hw = &adapter->hw;
@@ -4030,10 +4036,11 @@ static void e1000_phy_read_status(struct e1000_adapter *adapter)
 {
         struct e1000_hw *hw = &adapter->hw;
         struct e1000_phy_regs *phy = &adapter->phy_regs;
-        int ret_val;
 
         if ((er32(STATUS) & E1000_STATUS_LU) &&
             (adapter->hw.phy.media_type == e1000_media_type_copper)) {
+                int ret_val;
+
                 ret_val  = e1e_rphy(hw, PHY_CONTROL, &phy->bmcr);
                 ret_val |= e1e_rphy(hw, PHY_STATUS, &phy->bmsr);
                 ret_val |= e1e_rphy(hw, PHY_AUTONEG_ADV, &phy->advertise);
@@ -4179,7 +4186,6 @@ static void e1000_watchdog_task(struct work_struct *work)
         struct e1000_ring *tx_ring = adapter->tx_ring;
         struct e1000_hw *hw = &adapter->hw;
         u32 link, tctl;
-        int tx_pending = 0;
 
         if (test_bit(__E1000_DOWN, &adapter->state))
                 return;
@@ -4320,7 +4326,9 @@ static void e1000_watchdog_task(struct work_struct *work)
         }
 
 link_up:
+        spin_lock(&adapter->stats64_lock);
         e1000e_update_stats(adapter);
+        spin_unlock(&adapter->stats64_lock);
 
         mac->tx_packet_delta = adapter->stats.tpt - adapter->tpt_old;
         adapter->tpt_old = adapter->stats.tpt;
@@ -4334,20 +4342,17 @@ link_up:
 
         e1000e_update_adaptive(&adapter->hw);
 
-        if (!netif_carrier_ok(netdev)) {
-                tx_pending = (e1000_desc_unused(tx_ring) + 1 <
-                               tx_ring->count);
-                if (tx_pending) {
-                        /*
-                         * We've lost link, so the controller stops DMA,
-                         * but we've got queued Tx work that's never going
-                         * to get done, so reset controller to flush Tx.
-                         * (Do the reset outside of interrupt context).
-                         */
-                        schedule_work(&adapter->reset_task);
-                        /* return immediately since reset is imminent */
-                        return;
-                }
+        if (!netif_carrier_ok(netdev) &&
+            (e1000_desc_unused(tx_ring) + 1 < tx_ring->count)) {
+                /*
+                 * We've lost link, so the controller stops DMA,
+                 * but we've got queued Tx work that's never going
+                 * to get done, so reset controller to flush Tx.
+                 * (Do the reset outside of interrupt context).
+                 */
+                schedule_work(&adapter->reset_task);
+                /* return immediately since reset is imminent */
+                return;
         }
 
         /* Simple mode for Interrupt Throttle Rate (ITR) */
@@ -4411,13 +4416,13 @@ static int e1000_tso(struct e1000_adapter *adapter,
         u32 cmd_length = 0;
         u16 ipcse = 0, tucse, mss;
         u8 ipcss, ipcso, tucss, tucso, hdr_len;
-        int err;
 
         if (!skb_is_gso(skb))
                 return 0;
 
         if (skb_header_cloned(skb)) {
-                err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
+                int err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
+
                 if (err)
                         return err;
         }
@@ -4928,16 +4933,55 @@ static void e1000_reset_task(struct work_struct *work)
 }
 
 /**
- * e1000_get_stats - Get System Network Statistics
+ * e1000_get_stats64 - Get System Network Statistics
  * @netdev: network interface device structure
+ * @stats: rtnl_link_stats64 pointer
  *
  * Returns the address of the device statistics structure.
- * The statistics are actually updated from the timer callback.
  **/
-static struct net_device_stats *e1000_get_stats(struct net_device *netdev)
+struct rtnl_link_stats64 *e1000e_get_stats64(struct net_device *netdev,
+                                             struct rtnl_link_stats64 *stats)
 {
-        /* only return the current stats */
-        return &netdev->stats;
+        struct e1000_adapter *adapter = netdev_priv(netdev);
+
+        memset(stats, 0, sizeof(struct rtnl_link_stats64));
+        spin_lock(&adapter->stats64_lock);
+        e1000e_update_stats(adapter);
+        /* Fill out the OS statistics structure */
+        stats->rx_bytes = adapter->stats.gorc;
+        stats->rx_packets = adapter->stats.gprc;
+        stats->tx_bytes = adapter->stats.gotc;
+        stats->tx_packets = adapter->stats.gptc;
+        stats->multicast = adapter->stats.mprc;
+        stats->collisions = adapter->stats.colc;
+
+        /* Rx Errors */
+
+        /*
+         * RLEC on some newer hardware can be incorrect so build
+         * our own version based on RUC and ROC
+         */
+        stats->rx_errors = adapter->stats.rxerrc +
+                adapter->stats.crcerrs + adapter->stats.algnerrc +
+                adapter->stats.ruc + adapter->stats.roc +
+                adapter->stats.cexterr;
+        stats->rx_length_errors = adapter->stats.ruc +
+                                              adapter->stats.roc;
+        stats->rx_crc_errors = adapter->stats.crcerrs;
+        stats->rx_frame_errors = adapter->stats.algnerrc;
+        stats->rx_missed_errors = adapter->stats.mpc;
+
+        /* Tx Errors */
+        stats->tx_errors = adapter->stats.ecol +
+                                       adapter->stats.latecol;
+        stats->tx_aborted_errors = adapter->stats.ecol;
+        stats->tx_window_errors = adapter->stats.latecol;
+        stats->tx_carrier_errors = adapter->stats.tncrs;
+
+        /* Tx Dropped needs to be maintained elsewhere */
+
+        spin_unlock(&adapter->stats64_lock);
+        return stats;
 }
 
 /**
@@ -5507,9 +5551,10 @@ static irqreturn_t e1000_intr_msix(int irq, void *data)
 {
         struct net_device *netdev = data;
         struct e1000_adapter *adapter = netdev_priv(netdev);
-        int vector, msix_irq;
 
         if (adapter->msix_entries) {
+                int vector, msix_irq;
+
                 vector = 0;
                 msix_irq = adapter->msix_entries[vector].vector;
                 disable_irq(msix_irq);
@@ -5706,7 +5751,7 @@ static const struct net_device_ops e1000e_netdev_ops = {
         .ndo_open               = e1000_open,
         .ndo_stop               = e1000_close,
         .ndo_start_xmit         = e1000_xmit_frame,
-        .ndo_get_stats          = e1000_get_stats,
+        .ndo_get_stats64        = e1000e_get_stats64,
         .ndo_set_multicast_list = e1000_set_multi,
         .ndo_set_mac_address    = e1000_set_mac,
         .ndo_change_mtu         = e1000_change_mtu,
diff --git a/drivers/net/e1000e/phy.c b/drivers/net/e1000e/phy.c
index 6bea051b134b..6ae31fcfb629 100644
--- a/drivers/net/e1000e/phy.c
+++ b/drivers/net/e1000e/phy.c
@@ -2409,9 +2409,7 @@ static u32 e1000_get_phy_addr_for_bm_page(u32 page, u32 reg)
 s32 e1000e_write_phy_reg_bm(struct e1000_hw *hw, u32 offset, u16 data)
 {
         s32 ret_val;
-        u32 page_select = 0;
         u32 page = offset >> IGP_PAGE_SHIFT;
-        u32 page_shift = 0;
 
         ret_val = hw->phy.ops.acquire(hw);
         if (ret_val)
@@ -2427,6 +2425,8 @@ s32 e1000e_write_phy_reg_bm(struct e1000_hw *hw, u32 offset, u16 data)
         hw->phy.addr = e1000_get_phy_addr_for_bm_page(page, offset);
 
         if (offset > MAX_PHY_MULTI_PAGE_REG) {
+                u32 page_shift, page_select;
+
                 /*
                  * Page select is register 31 for phy address 1 and 22 for
                  * phy address 2 and 3. Page select is shifted only for
@@ -2468,9 +2468,7 @@ out:
 s32 e1000e_read_phy_reg_bm(struct e1000_hw *hw, u32 offset, u16 *data)
 {
         s32 ret_val;
-        u32 page_select = 0;
         u32 page = offset >> IGP_PAGE_SHIFT;
-        u32 page_shift = 0;
 
         ret_val = hw->phy.ops.acquire(hw);
         if (ret_val)
@@ -2486,6 +2484,8 @@ s32 e1000e_read_phy_reg_bm(struct e1000_hw *hw, u32 offset, u16 *data)
         hw->phy.addr = e1000_get_phy_addr_for_bm_page(page, offset);
 
         if (offset > MAX_PHY_MULTI_PAGE_REG) {
+                u32 page_shift, page_select;
+
                 /*
                  * Page select is register 31 for phy address 1 and 22 for
                  * phy address 2 and 3. Page select is shifted only for