10 files changed, 238 insertions, 213 deletions

diff --git a/drivers/net/ixgbevf/Makefile b/drivers/net/ixgbevf/Makefile
index dd4e0d27e8cc..1f35d229e71a 100644
--- a/drivers/net/ixgbevf/Makefile
+++ b/drivers/net/ixgbevf/Makefile
@@ -1,7 +1,7 @@
 ################################################################################
 #
 # Intel 82599 Virtual Function driver
-# Copyright(c) 1999 - 2009 Intel Corporation.
+# Copyright(c) 1999 - 2010 Intel Corporation.
 #
 # This program is free software; you can redistribute it and/or modify it
 # under the terms and conditions of the GNU General Public License,
diff --git a/drivers/net/ixgbevf/defines.h b/drivers/net/ixgbevf/defines.h
index ca2c81f49a05..78abb6f1a866 100644
--- a/drivers/net/ixgbevf/defines.h
+++ b/drivers/net/ixgbevf/defines.h
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 82599 Virtual Function driver
-  Copyright(c) 1999 - 2009 Intel Corporation.
+  Copyright(c) 1999 - 2010 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -30,6 +30,7 @@
 
 /* Device IDs */
 #define IXGBE_DEV_ID_82599_VF           0x10ED
+#define IXGBE_DEV_ID_X540_VF            0x1515
 
 #define IXGBE_VF_IRQ_CLEAR_MASK         7
 #define IXGBE_VF_MAX_TX_QUEUES          1
@@ -64,6 +65,8 @@ typedef u32 ixgbe_link_speed;
 #define IXGBE_RXCTRL_DMBYPS     0x00000002  /* Descriptor Monitor Bypass */
 #define IXGBE_RXDCTL_ENABLE     0x02000000  /* Enable specific Rx Queue */
 #define IXGBE_RXDCTL_VME        0x40000000  /* VLAN mode enable */
+#define IXGBE_RXDCTL_RLPMLMASK  0x00003FFF  /* Only supported on the X540 */
+#define IXGBE_RXDCTL_RLPML_EN   0x00008000
 
 /* DCA Control */
 #define IXGBE_DCA_TXCTRL_TX_WB_RO_EN (1 << 11) /* Tx Desc writeback RO bit */
diff --git a/drivers/net/ixgbevf/ethtool.c b/drivers/net/ixgbevf/ethtool.c
index 4680b069b84f..deee3754b1f7 100644
--- a/drivers/net/ixgbevf/ethtool.c
+++ b/drivers/net/ixgbevf/ethtool.c
@@ -104,11 +104,13 @@ static int ixgbevf_get_settings(struct net_device *netdev,
         hw->mac.ops.check_link(hw, &link_speed, &link_up, false);
 
         if (link_up) {
-                ecmd->speed = (link_speed == IXGBE_LINK_SPEED_10GB_FULL) ?
-                               SPEED_10000 : SPEED_1000;
+                ethtool_cmd_speed_set(
+                        ecmd,
+                        (link_speed == IXGBE_LINK_SPEED_10GB_FULL) ?
+                        SPEED_10000 : SPEED_1000);
                 ecmd->duplex = DUPLEX_FULL;
         } else {
-                ecmd->speed = -1;
+                ethtool_cmd_speed_set(ecmd, -1);
                 ecmd->duplex = -1;
         }
 
@@ -172,7 +174,7 @@ static char *ixgbevf_reg_names[] = {
         "IXGBE_VFSTATUS",
         "IXGBE_VFLINKS",
         "IXGBE_VFRXMEMWRAP",
-        "IXGBE_VFRTIMER",
+        "IXGBE_VFFRTIMER",
         "IXGBE_VTEICR",
         "IXGBE_VTEICS",
         "IXGBE_VTEIMS",
@@ -240,7 +242,7 @@ static void ixgbevf_get_regs(struct net_device *netdev,
         regs_buff[1] = IXGBE_READ_REG(hw, IXGBE_VFSTATUS);
         regs_buff[2] = IXGBE_READ_REG(hw, IXGBE_VFLINKS);
         regs_buff[3] = IXGBE_READ_REG(hw, IXGBE_VFRXMEMWRAP);
-        regs_buff[4] = IXGBE_READ_REG(hw, IXGBE_VFRTIMER);
+        regs_buff[4] = IXGBE_READ_REG(hw, IXGBE_VFFRTIMER);
 
         /* Interrupt */
         /* don't read EICR because it can clear interrupt causes, instead
@@ -330,10 +332,8 @@ static int ixgbevf_set_ringparam(struct net_device *netdev,
 {
         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
         struct ixgbevf_ring *tx_ring = NULL, *rx_ring = NULL;
-        int i, err;
+        int i, err = 0;
         u32 new_rx_count, new_tx_count;
-        bool need_tx_update = false;
-        bool need_rx_update = false;
 
         if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
                 return -EINVAL;
@@ -355,89 +355,96 @@ static int ixgbevf_set_ringparam(struct net_device *netdev,
         while (test_and_set_bit(__IXGBEVF_RESETTING, &adapter->state))
                 msleep(1);
 
-        if (new_tx_count != adapter->tx_ring_count) {
-                tx_ring = kcalloc(adapter->num_tx_queues,
-                                  sizeof(struct ixgbevf_ring), GFP_KERNEL);
-                if (!tx_ring) {
-                        err = -ENOMEM;
-                        goto err_setup;
-                }
-                memcpy(tx_ring, adapter->tx_ring,
-                       adapter->num_tx_queues * sizeof(struct ixgbevf_ring));
-                for (i = 0; i < adapter->num_tx_queues; i++) {
-                        tx_ring[i].count = new_tx_count;
-                        err = ixgbevf_setup_tx_resources(adapter,
-                                                         &tx_ring[i]);
-                        if (err) {
-                                while (i) {
-                                        i--;
-                                        ixgbevf_free_tx_resources(adapter,
-                                                                  &tx_ring[i]);
-                                }
-                                kfree(tx_ring);
-                                goto err_setup;
-                        }
-                        tx_ring[i].v_idx = adapter->tx_ring[i].v_idx;
-                }
-                need_tx_update = true;
+        /*
+         * If the adapter isn't up and running then just set the
+         * new parameters and scurry for the exits.
+         */
+        if (!netif_running(adapter->netdev)) {
+                for (i = 0; i < adapter->num_tx_queues; i++)
+                        adapter->tx_ring[i].count = new_tx_count;
+                for (i = 0; i < adapter->num_rx_queues; i++)
+                        adapter->rx_ring[i].count = new_rx_count;
+                adapter->tx_ring_count = new_tx_count;
+                adapter->rx_ring_count = new_rx_count;
+                goto clear_reset;
         }
 
-        if (new_rx_count != adapter->rx_ring_count) {
-                rx_ring = kcalloc(adapter->num_rx_queues,
-                                  sizeof(struct ixgbevf_ring), GFP_KERNEL);
-                if ((!rx_ring) && (need_tx_update)) {
-                        err = -ENOMEM;
-                        goto err_rx_setup;
-                }
-                memcpy(rx_ring, adapter->rx_ring,
-                       adapter->num_rx_queues * sizeof(struct ixgbevf_ring));
-                for (i = 0; i < adapter->num_rx_queues; i++) {
-                        rx_ring[i].count = new_rx_count;
-                        err = ixgbevf_setup_rx_resources(adapter,
-                                                         &rx_ring[i]);
-                        if (err) {
-                                while (i) {
-                                        i--;
-                                        ixgbevf_free_rx_resources(adapter,
-                                                                  &rx_ring[i]);
-                                }
-                                kfree(rx_ring);
-                                goto err_rx_setup;
-                        }
-                        rx_ring[i].v_idx = adapter->rx_ring[i].v_idx;
-                }
-                need_rx_update = true;
+        tx_ring = kcalloc(adapter->num_tx_queues,
+                          sizeof(struct ixgbevf_ring), GFP_KERNEL);
+        if (!tx_ring) {
+                err = -ENOMEM;
+                goto clear_reset;
         }
 
-err_rx_setup:
-        /* if rings need to be updated, here's the place to do it in one shot */
-        if (need_tx_update || need_rx_update) {
-                if (netif_running(netdev))
-                        ixgbevf_down(adapter);
+        rx_ring = kcalloc(adapter->num_rx_queues,
+                          sizeof(struct ixgbevf_ring), GFP_KERNEL);
+        if (!rx_ring) {
+                err = -ENOMEM;
+                goto err_rx_setup;
         }
 
-        /* tx */
-        if (need_tx_update) {
-                kfree(adapter->tx_ring);
-                adapter->tx_ring = tx_ring;
-                tx_ring = NULL;
-                adapter->tx_ring_count = new_tx_count;
+        ixgbevf_down(adapter);
+
+        memcpy(tx_ring, adapter->tx_ring,
+               adapter->num_tx_queues * sizeof(struct ixgbevf_ring));
+        for (i = 0; i < adapter->num_tx_queues; i++) {
+                tx_ring[i].count = new_tx_count;
+                err = ixgbevf_setup_tx_resources(adapter, &tx_ring[i]);
+                if (err) {
+                        while (i) {
+                                i--;
+                                ixgbevf_free_tx_resources(adapter,
+                                                          &tx_ring[i]);
+                        }
+                        goto err_tx_ring_setup;
+                }
+                tx_ring[i].v_idx = adapter->tx_ring[i].v_idx;
         }
 
-        /* rx */
-        if (need_rx_update) {
-                kfree(adapter->rx_ring);
-                adapter->rx_ring = rx_ring;
-                rx_ring = NULL;
-                adapter->rx_ring_count = new_rx_count;
+        memcpy(rx_ring, adapter->rx_ring,
+               adapter->num_rx_queues * sizeof(struct ixgbevf_ring));
+        for (i = 0; i < adapter->num_rx_queues; i++) {
+                rx_ring[i].count = new_rx_count;
+                err = ixgbevf_setup_rx_resources(adapter, &rx_ring[i]);
+                if (err) {
+                        while (i) {
+                                i--;
+                                ixgbevf_free_rx_resources(adapter,
+                                                          &rx_ring[i]);
+                        }
+                                goto err_rx_ring_setup;
+                }
+                rx_ring[i].v_idx = adapter->rx_ring[i].v_idx;
         }
 
+        /*
+         * Only switch to new rings if all the prior allocations
+         * and ring setups have succeeded.
+         */
+        kfree(adapter->tx_ring);
+        adapter->tx_ring = tx_ring;
+        adapter->tx_ring_count = new_tx_count;
+
+        kfree(adapter->rx_ring);
+        adapter->rx_ring = rx_ring;
+        adapter->rx_ring_count = new_rx_count;
+
         /* success! */
-        err = 0;
-        if (netif_running(netdev))
-                ixgbevf_up(adapter);
+        ixgbevf_up(adapter);
 
-err_setup:
+        goto clear_reset;
+
+err_rx_ring_setup:
+        for(i = 0; i < adapter->num_tx_queues; i++)
+                ixgbevf_free_tx_resources(adapter, &tx_ring[i]);
+
+err_tx_ring_setup:
+        kfree(rx_ring);
+
+err_rx_setup:
+        kfree(tx_ring);
+
+clear_reset:
         clear_bit(__IXGBEVF_RESETTING, &adapter->state);
         return err;
 }
@@ -539,7 +546,7 @@ struct ixgbevf_reg_test {
 #define TABLE64_TEST_HI 6
 
 /* default VF register test */
-static struct ixgbevf_reg_test reg_test_vf[] = {
+static const struct ixgbevf_reg_test reg_test_vf[] = {
         { IXGBE_VFRDBAL(0), 2, PATTERN_TEST, 0xFFFFFF80, 0xFFFFFF80 },
         { IXGBE_VFRDBAH(0), 2, PATTERN_TEST, 0xFFFFFFFF, 0xFFFFFFFF },
         { IXGBE_VFRDLEN(0), 2, PATTERN_TEST, 0x000FFF80, 0x000FFFFF },
@@ -552,19 +559,23 @@ static struct ixgbevf_reg_test reg_test_vf[] = {
         { 0, 0, 0, 0 }
 };
 
+static const u32 register_test_patterns[] = {
+        0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF
+};
+
 #define REG_PATTERN_TEST(R, M, W)                                             \
 {                                                                             \
         u32 pat, val, before;                                                 \
-        const u32 _test[] = {0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF}; \
-        for (pat = 0; pat < ARRAY_SIZE(_test); pat++) {                       \
+        for (pat = 0; pat < ARRAY_SIZE(register_test_patterns); pat++) {      \
                 before = readl(adapter->hw.hw_addr + R);                      \
-                writel((_test[pat] & W), (adapter->hw.hw_addr + R));          \
+                writel((register_test_patterns[pat] & W),                     \
+                       (adapter->hw.hw_addr + R));                            \
                 val = readl(adapter->hw.hw_addr + R);                         \
-                if (val != (_test[pat] & W & M)) {                            \
+                if (val != (register_test_patterns[pat] & W & M)) {           \
                         hw_dbg(&adapter->hw,                                  \
                         "pattern test reg %04X failed: got "                  \
                         "0x%08X expected 0x%08X\n",                           \
-                        R, val, (_test[pat] & W & M));                        \
+                        R, val, (register_test_patterns[pat] & W & M));       \
                         *data = R;                                            \
                         writel(before, adapter->hw.hw_addr + R);              \
                         return 1;                                             \
@@ -591,7 +602,7 @@ static struct ixgbevf_reg_test reg_test_vf[] = {
 
 static int ixgbevf_reg_test(struct ixgbevf_adapter *adapter, u64 *data)
 {
-        struct ixgbevf_reg_test *test;
+        const struct ixgbevf_reg_test *test;
         u32 i;
 
         test = reg_test_vf;
diff --git a/drivers/net/ixgbevf/ixgbevf.h b/drivers/net/ixgbevf/ixgbevf.h
index f7015efbff05..b703f60be3b7 100644
--- a/drivers/net/ixgbevf/ixgbevf.h
+++ b/drivers/net/ixgbevf/ixgbevf.h
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 82599 Virtual Function driver
-  Copyright(c) 1999 - 2009 Intel Corporation.
+  Copyright(c) 1999 - 2010 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -207,7 +207,6 @@ struct ixgbevf_adapter {
         u64 hw_tso_ctxt;
         u64 hw_tso6_ctxt;
         u32 tx_timeout_count;
-        bool detect_tx_hung;
 
         /* RX */
         struct ixgbevf_ring *rx_ring;   /* One per active queue */
@@ -243,7 +242,6 @@ struct ixgbevf_adapter {
         /* OS defined structs */
         struct net_device *netdev;
         struct pci_dev *pdev;
-        struct net_device_stats net_stats;
 
         /* structs defined in ixgbe_vf.h */
         struct ixgbe_hw hw;
@@ -276,9 +274,11 @@ enum ixbgevf_state_t {
 
 enum ixgbevf_boards {
         board_82599_vf,
+        board_X540_vf,
 };
 
-extern struct ixgbevf_info ixgbevf_vf_info;
+extern struct ixgbevf_info ixgbevf_82599_vf_info;
+extern struct ixgbevf_info ixgbevf_X540_vf_info;
 extern struct ixgbe_mac_operations ixgbevf_mbx_ops;
 
 /* needed by ethtool.c */
diff --git a/drivers/net/ixgbevf/ixgbevf_main.c b/drivers/net/ixgbevf/ixgbevf_main.c
index 918c00359b0a..28d3cb21d376 100644
--- a/drivers/net/ixgbevf/ixgbevf_main.c
+++ b/drivers/net/ixgbevf/ixgbevf_main.c
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 82599 Virtual Function driver
-  Copyright(c) 1999 - 2009 Intel Corporation.
+  Copyright(c) 1999 - 2010 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -44,19 +44,22 @@
 #include <net/ip6_checksum.h>
 #include <linux/ethtool.h>
 #include <linux/if_vlan.h>
+#include <linux/prefetch.h>
 
 #include "ixgbevf.h"
 
 char ixgbevf_driver_name[] = "ixgbevf";
 static const char ixgbevf_driver_string[] =
-        "Intel(R) 82599 Virtual Function";
+        "Intel(R) 10 Gigabit PCI Express Virtual Function Network Driver";
 
-#define DRV_VERSION "1.0.0-k0"
+#define DRV_VERSION "2.0.0-k2"
 const char ixgbevf_driver_version[] = DRV_VERSION;
-static char ixgbevf_copyright[] = "Copyright (c) 2009 Intel Corporation.";
+static char ixgbevf_copyright[] =
+        "Copyright (c) 2009 - 2010 Intel Corporation.";
 
 static const struct ixgbevf_info *ixgbevf_info_tbl[] = {
-        [board_82599_vf] = &ixgbevf_vf_info,
+        [board_82599_vf] = &ixgbevf_82599_vf_info,
+        [board_X540_vf]  = &ixgbevf_X540_vf_info,
 };
 
 /* ixgbevf_pci_tbl - PCI Device ID Table
@@ -70,6 +73,8 @@ static const struct ixgbevf_info *ixgbevf_info_tbl[] = {
 static struct pci_device_id ixgbevf_pci_tbl[] = {
         {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_VF),
         board_82599_vf},
+        {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X540_VF),
+        board_X540_vf},
 
         /* required last entry */
         {0, }
@@ -103,7 +108,7 @@ static inline void ixgbevf_release_rx_desc(struct ixgbe_hw *hw,
 }
 
 /*
- * ixgbe_set_ivar - set the IVAR registers, mapping interrupt causes to vectors
+ * ixgbevf_set_ivar - set IVAR registers - maps interrupt causes to vectors
  * @adapter: pointer to adapter struct
  * @direction: 0 for Rx, 1 for Tx, -1 for other causes
  * @queue: queue to map the corresponding interrupt to
@@ -158,42 +163,6 @@ static void ixgbevf_unmap_and_free_tx_resource(struct ixgbevf_adapter *adapter,
         /* tx_buffer_info must be completely set up in the transmit path */
 }
 
-static inline bool ixgbevf_check_tx_hang(struct ixgbevf_adapter *adapter,
-                                         struct ixgbevf_ring *tx_ring,
-                                         unsigned int eop)
-{
-        struct ixgbe_hw *hw = &adapter->hw;
-        u32 head, tail;
-
-        /* Detect a transmit hang in hardware, this serializes the
-         * check with the clearing of time_stamp and movement of eop */
-        head = readl(hw->hw_addr + tx_ring->head);
-        tail = readl(hw->hw_addr + tx_ring->tail);
-        adapter->detect_tx_hung = false;
-        if ((head != tail) &&
-            tx_ring->tx_buffer_info[eop].time_stamp &&
-            time_after(jiffies, tx_ring->tx_buffer_info[eop].time_stamp + HZ)) {
-                /* detected Tx unit hang */
-                union ixgbe_adv_tx_desc *tx_desc;
-                tx_desc = IXGBE_TX_DESC_ADV(*tx_ring, eop);
-                printk(KERN_ERR "Detected Tx Unit Hang\n"
-                       "  Tx Queue             <%d>\n"
-                       "  TDH, TDT             <%x>, <%x>\n"
-                       "  next_to_use          <%x>\n"
-                       "  next_to_clean        <%x>\n"
-                       "tx_buffer_info[next_to_clean]\n"
-                       "  time_stamp           <%lx>\n"
-                       "  jiffies              <%lx>\n",
-                       tx_ring->queue_index,
-                       head, tail,
-                       tx_ring->next_to_use, eop,
-                       tx_ring->tx_buffer_info[eop].time_stamp, jiffies);
-                return true;
-        }
-
-        return false;
-}
-
 #define IXGBE_MAX_TXD_PWR       14
 #define IXGBE_MAX_DATA_PER_TXD  (1 << IXGBE_MAX_TXD_PWR)
 
@@ -289,16 +258,6 @@ static bool ixgbevf_clean_tx_irq(struct ixgbevf_adapter *adapter,
 #endif
         }
 
-        if (adapter->detect_tx_hung) {
-                if (ixgbevf_check_tx_hang(adapter, tx_ring, i)) {
-                        /* schedule immediate reset if we believe we hung */
-                        printk(KERN_INFO
-                               "tx hang %d detected, resetting adapter\n",
-                               adapter->tx_timeout_count + 1);
-                        ixgbevf_tx_timeout(adapter->netdev);
-                }
-        }
-
         /* re-arm the interrupt */
         if ((count >= tx_ring->work_limit) &&
             (!test_bit(__IXGBEVF_DOWN, &adapter->state))) {
@@ -308,10 +267,10 @@ static bool ixgbevf_clean_tx_irq(struct ixgbevf_adapter *adapter,
         tx_ring->total_bytes += total_bytes;
         tx_ring->total_packets += total_packets;
 
-        adapter->net_stats.tx_bytes += total_bytes;
-        adapter->net_stats.tx_packets += total_packets;
+        netdev->stats.tx_bytes += total_bytes;
+        netdev->stats.tx_packets += total_packets;
 
-        return (count < tx_ring->work_limit);
+        return count < tx_ring->work_limit;
 }
 
 /**
@@ -330,7 +289,6 @@ static void ixgbevf_receive_skb(struct ixgbevf_q_vector *q_vector,
         struct ixgbevf_adapter *adapter = q_vector->adapter;
         bool is_vlan = (status & IXGBE_RXD_STAT_VP);
         u16 tag = le16_to_cpu(rx_desc->wb.upper.vlan);
-        int ret;
 
         if (!(adapter->flags & IXGBE_FLAG_IN_NETPOLL)) {
                 if (adapter->vlgrp && is_vlan)
@@ -341,9 +299,9 @@ static void ixgbevf_receive_skb(struct ixgbevf_q_vector *q_vector,
                         napi_gro_receive(&q_vector->napi, skb);
         } else {
                 if (adapter->vlgrp && is_vlan)
-                        ret = vlan_hwaccel_rx(skb, adapter->vlgrp, tag);
+                        vlan_hwaccel_rx(skb, adapter->vlgrp, tag);
                 else
-                        ret = netif_rx(skb);
+                        netif_rx(skb);
         }
 }
 
@@ -356,7 +314,7 @@ static void ixgbevf_receive_skb(struct ixgbevf_q_vector *q_vector,
 static inline void ixgbevf_rx_checksum(struct ixgbevf_adapter *adapter,
                                        u32 status_err, struct sk_buff *skb)
 {
-        skb->ip_summed = CHECKSUM_NONE;
+        skb_checksum_none_assert(skb);
 
         /* Rx csum disabled */
         if (!(adapter->flags & IXGBE_FLAG_RX_CSUM_ENABLED))
@@ -639,8 +597,8 @@ next_desc:
 
         rx_ring->total_packets += total_rx_packets;
         rx_ring->total_bytes += total_rx_bytes;
-        adapter->net_stats.rx_bytes += total_rx_bytes;
-        adapter->net_stats.rx_packets += total_rx_packets;
+        adapter->netdev->stats.rx_bytes += total_rx_bytes;
+        adapter->netdev->stats.rx_packets += total_rx_packets;
 
         return cleaned;
 }
@@ -1013,7 +971,7 @@ static irqreturn_t ixgbevf_msix_clean_tx(int irq, void *data)
 }
 
 /**
- * ixgbe_msix_clean_rx - single unshared vector rx clean (all queues)
+ * ixgbevf_msix_clean_rx - single unshared vector rx clean (all queues)
  * @irq: unused
  * @data: pointer to our q_vector struct for this interrupt vector
  **/
@@ -1495,7 +1453,7 @@ static void ixgbevf_restore_vlan(struct ixgbevf_adapter *adapter)
 
         if (adapter->vlgrp) {
                 u16 vid;
-                for (vid = 0; vid < VLAN_GROUP_ARRAY_LEN; vid++) {
+                for (vid = 0; vid < VLAN_N_VID; vid++) {
                         if (!vlan_group_get_device(adapter->vlgrp, vid))
                                 continue;
                         ixgbevf_vlan_rx_add_vid(adapter->netdev, vid);
@@ -1503,6 +1461,34 @@ static void ixgbevf_restore_vlan(struct ixgbevf_adapter *adapter)
         }
 }
 
+static int ixgbevf_write_uc_addr_list(struct net_device *netdev)
+{
+        struct ixgbevf_adapter *adapter = netdev_priv(netdev);
+        struct ixgbe_hw *hw = &adapter->hw;
+        int count = 0;
+
+        if ((netdev_uc_count(netdev)) > 10) {
+                printk(KERN_ERR "Too many unicast filters - No Space\n");
+                return -ENOSPC;
+        }
+
+        if (!netdev_uc_empty(netdev)) {
+                struct netdev_hw_addr *ha;
+                netdev_for_each_uc_addr(ha, netdev) {
+                        hw->mac.ops.set_uc_addr(hw, ++count, ha->addr);
+                        udelay(200);
+                }
+        } else {
+                /*
+                 * If the list is empty then send message to PF driver to
+                 * clear all macvlans on this VF.
+                 */
+                hw->mac.ops.set_uc_addr(hw, 0, NULL);
+        }
+
+        return count;
+}
+
 /**
  * ixgbevf_set_rx_mode - Multicast set
  * @netdev: network interface device structure
@@ -1519,6 +1505,8 @@ static void ixgbevf_set_rx_mode(struct net_device *netdev)
         /* reprogram multicast list */
         if (hw->mac.ops.update_mc_addr_list)
                 hw->mac.ops.update_mc_addr_list(hw, netdev);
+
+        ixgbevf_write_uc_addr_list(netdev);
 }
 
 static void ixgbevf_napi_enable_all(struct ixgbevf_adapter *adapter)
@@ -1661,6 +1649,11 @@ static int ixgbevf_up_complete(struct ixgbevf_adapter *adapter)
                 j = adapter->rx_ring[i].reg_idx;
                 rxdctl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j));
                 rxdctl |= IXGBE_RXDCTL_ENABLE;
+                if (hw->mac.type == ixgbe_mac_X540_vf) {
+                        rxdctl &= ~IXGBE_RXDCTL_RLPMLMASK;
+                        rxdctl |= ((netdev->mtu + ETH_HLEN + ETH_FCS_LEN) |
+                                   IXGBE_RXDCTL_RLPML_EN);
+                }
                 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(j), rxdctl);
                 ixgbevf_rx_desc_queue_enable(adapter, i);
         }
@@ -1963,7 +1956,7 @@ static void ixgbevf_acquire_msix_vectors(struct ixgbevf_adapter *adapter,
 }
 
 /*
- * ixgbe_set_num_queues: Allocate queues for device, feature dependant
+ * ixgbevf_set_num_queues: Allocate queues for device, feature dependent
  * @adapter: board private structure to initialize
  *
  * This is the top level queue allocation routine.  The order here is very
@@ -2212,7 +2205,7 @@ static int __devinit ixgbevf_sw_init(struct ixgbevf_adapter *adapter)
 
         hw->vendor_id = pdev->vendor;
         hw->device_id = pdev->device;
-        pci_read_config_byte(pdev, PCI_REVISION_ID, &hw->revision_id);
+        hw->revision_id = pdev->revision;
         hw->subsystem_vendor_id = pdev->subsystem_vendor;
         hw->subsystem_device_id = pdev->subsystem_device;
 
@@ -2297,7 +2290,7 @@ void ixgbevf_update_stats(struct ixgbevf_adapter *adapter)
                                 adapter->stats.vfmprc);
 
         /* Fill out the OS statistics structure */
-        adapter->net_stats.multicast = adapter->stats.vfmprc -
+        adapter->netdev->stats.multicast = adapter->stats.vfmprc -
                 adapter->stats.base_vfmprc;
 }
 
@@ -2406,9 +2399,6 @@ static void ixgbevf_watchdog_task(struct work_struct *work)
                                10 : 1);
                         netif_carrier_on(netdev);
                         netif_tx_wake_all_queues(netdev);
-                } else {
-                        /* Force detection of hung controller */
-                        adapter->detect_tx_hung = true;
                 }
         } else {
                 adapter->link_up = false;
@@ -2423,9 +2413,6 @@ static void ixgbevf_watchdog_task(struct work_struct *work)
         ixgbevf_update_stats(adapter);
 
 pf_has_reset:
-        /* Force detection of hung controller every watchdog period */
-        adapter->detect_tx_hung = true;
-
         /* Reset the timer */
         if (!test_bit(__IXGBEVF_DOWN, &adapter->state))
                 mod_timer(&adapter->watchdog_timer,
@@ -2488,10 +2475,9 @@ int ixgbevf_setup_tx_resources(struct ixgbevf_adapter *adapter,
         int size;
 
         size = sizeof(struct ixgbevf_tx_buffer) * tx_ring->count;
-        tx_ring->tx_buffer_info = vmalloc(size);
+        tx_ring->tx_buffer_info = vzalloc(size);
         if (!tx_ring->tx_buffer_info)
                 goto err;
-        memset(tx_ring->tx_buffer_info, 0, size);
 
         /* round up to nearest 4K */
         tx_ring->size = tx_ring->count * sizeof(union ixgbe_adv_tx_desc);
@@ -2555,14 +2541,13 @@ int ixgbevf_setup_rx_resources(struct ixgbevf_adapter *adapter,
         int size;
 
         size = sizeof(struct ixgbevf_rx_buffer) * rx_ring->count;
-        rx_ring->rx_buffer_info = vmalloc(size);
+        rx_ring->rx_buffer_info = vzalloc(size);
         if (!rx_ring->rx_buffer_info) {
                 hw_dbg(&adapter->hw,
                        "Unable to vmalloc buffer memory for "
                        "the receive descriptor ring\n");
                 goto alloc_failed;
         }
-        memset(rx_ring->rx_buffer_info, 0, size);
 
         /* Round up to nearest 4K */
         rx_ring->size = rx_ring->count * sizeof(union ixgbe_adv_rx_desc);
@@ -3134,7 +3119,7 @@ static int ixgbevf_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
 
         tx_ring = &adapter->tx_ring[r_idx];
 
-        if (adapter->vlgrp && vlan_tx_tag_present(skb)) {
+        if (vlan_tx_tag_present(skb)) {
                 tx_flags |= vlan_tx_tag_get(skb);
                 tx_flags <<= IXGBE_TX_FLAGS_VLAN_SHIFT;
                 tx_flags |= IXGBE_TX_FLAGS_VLAN;
@@ -3181,21 +3166,6 @@ static int ixgbevf_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
 }
 
 /**
- * ixgbevf_get_stats - Get System Network Statistics
- * @netdev: network interface device structure
- *
- * Returns the address of the device statistics structure.
- * The statistics are actually updated from the timer callback.
- **/
-static struct net_device_stats *ixgbevf_get_stats(struct net_device *netdev)
-{
-        struct ixgbevf_adapter *adapter = netdev_priv(netdev);
-
-        /* only return the current stats */
-        return &adapter->net_stats;
-}
-
-/**
  * ixgbevf_set_mac - Change the Ethernet Address of the NIC
  * @netdev: network interface device structure
  * @p: pointer to an address structure
@@ -3230,10 +3200,16 @@ static int ixgbevf_set_mac(struct net_device *netdev, void *p)
 static int ixgbevf_change_mtu(struct net_device *netdev, int new_mtu)
 {
         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
+        struct ixgbe_hw *hw = &adapter->hw;
         int max_frame = new_mtu + ETH_HLEN + ETH_FCS_LEN;
+        int max_possible_frame = MAXIMUM_ETHERNET_VLAN_SIZE;
+        u32 msg[2];
+
+        if (adapter->hw.mac.type == ixgbe_mac_X540_vf)
+                max_possible_frame = IXGBE_MAX_JUMBO_FRAME_SIZE;
 
         /* MTU < 68 is an error and causes problems on some kernels */
-        if ((new_mtu < 68) || (max_frame > MAXIMUM_ETHERNET_VLAN_SIZE))
+        if ((new_mtu < 68) || (max_frame > max_possible_frame))
                 return -EINVAL;
 
         hw_dbg(&adapter->hw, "changing MTU from %d to %d\n",
@@ -3241,6 +3217,10 @@ static int ixgbevf_change_mtu(struct net_device *netdev, int new_mtu)
         /* must set new MTU before calling down or up */
         netdev->mtu = new_mtu;
 
+        msg[0] = IXGBE_VF_SET_LPE;
+        msg[1] = max_frame;
+        hw->mbx.ops.write_posted(hw, msg, 2);
+
         if (netif_running(netdev))
                 ixgbevf_reinit_locked(adapter);
 
@@ -3272,7 +3252,6 @@ static const struct net_device_ops ixgbe_netdev_ops = {
         .ndo_open               = &ixgbevf_open,
         .ndo_stop               = &ixgbevf_close,
         .ndo_start_xmit         = &ixgbevf_xmit_frame,
-        .ndo_get_stats          = &ixgbevf_get_stats,
         .ndo_set_rx_mode        = &ixgbevf_set_rx_mode,
         .ndo_set_multicast_list = &ixgbevf_set_rx_mode,
         .ndo_validate_addr      = eth_validate_addr,
@@ -3286,8 +3265,6 @@ static const struct net_device_ops ixgbe_netdev_ops = {
 
 static void ixgbevf_assign_netdev_ops(struct net_device *dev)
 {
-        struct ixgbevf_adapter *adapter;
-        adapter = netdev_priv(dev);
         dev->netdev_ops = &ixgbe_netdev_ops;
         ixgbevf_set_ethtool_ops(dev);
         dev->watchdog_timeo = 5 * HZ;
@@ -3426,7 +3403,7 @@ static int __devinit ixgbevf_probe(struct pci_dev *pdev,
         }
 
         init_timer(&adapter->watchdog_timer);
-        adapter->watchdog_timer.function = &ixgbevf_watchdog;
+        adapter->watchdog_timer.function = ixgbevf_watchdog;
         adapter->watchdog_timer.data = (unsigned long)adapter;
 
         INIT_WORK(&adapter->reset_task, ixgbevf_reset_task);
@@ -3440,10 +3417,6 @@ static int __devinit ixgbevf_probe(struct pci_dev *pdev,
         if (hw->mac.ops.get_bus_info)
                 hw->mac.ops.get_bus_info(hw);
 
-
-        netif_carrier_off(netdev);
-        netif_tx_stop_all_queues(netdev);
-
         strcpy(netdev->name, "eth%d");
 
         err = register_netdev(netdev);
@@ -3452,6 +3425,8 @@ static int __devinit ixgbevf_probe(struct pci_dev *pdev,
 
         adapter->netdev_registered = true;
 
+        netif_carrier_off(netdev);
+
         ixgbevf_init_last_counter_stats(adapter);
 
         /* print the MAC address */
@@ -3503,10 +3478,9 @@ static void __devexit ixgbevf_remove(struct pci_dev *pdev)
 
         del_timer_sync(&adapter->watchdog_timer);
 
+        cancel_work_sync(&adapter->reset_task);
         cancel_work_sync(&adapter->watchdog_task);
 
-        flush_scheduled_work();
-
         if (adapter->netdev_registered) {
                 unregister_netdev(netdev);
                 adapter->netdev_registered = false;
@@ -3536,9 +3510,9 @@ static struct pci_driver ixgbevf_driver = {
 };
 
 /**
- * ixgbe_init_module - Driver Registration Routine
+ * ixgbevf_init_module - Driver Registration Routine
  *
- * ixgbe_init_module is the first routine called when the driver is
+ * ixgbevf_init_module is the first routine called when the driver is
  * loaded. All it does is register with the PCI subsystem.
  **/
 static int __init ixgbevf_init_module(void)
@@ -3556,9 +3530,9 @@ static int __init ixgbevf_init_module(void)
 module_init(ixgbevf_init_module);
 
 /**
- * ixgbe_exit_module - Driver Exit Cleanup Routine
+ * ixgbevf_exit_module - Driver Exit Cleanup Routine
  *
- * ixgbe_exit_module is called just before the driver is removed
+ * ixgbevf_exit_module is called just before the driver is removed
  * from memory.
  **/
 static void __exit ixgbevf_exit_module(void)
@@ -3568,7 +3542,7 @@ static void __exit ixgbevf_exit_module(void)
 
 #ifdef DEBUG
 /**
- * ixgbe_get_hw_dev_name - return device name string
+ * ixgbevf_get_hw_dev_name - return device name string
  * used by hardware layer to print debugging information
  **/
 char *ixgbevf_get_hw_dev_name(struct ixgbe_hw *hw)
diff --git a/drivers/net/ixgbevf/mbx.c b/drivers/net/ixgbevf/mbx.c
index b8143501e6fc..7a8833125770 100644
--- a/drivers/net/ixgbevf/mbx.c
+++ b/drivers/net/ixgbevf/mbx.c
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 82599 Virtual Function driver
-  Copyright(c) 1999 - 2009 Intel Corporation.
+  Copyright(c) 1999 - 2010 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -308,7 +308,7 @@ out_no_read:
  *
  *  Initializes the hw->mbx struct to correct values for vf mailbox
  */
-s32 ixgbevf_init_mbx_params_vf(struct ixgbe_hw *hw)
+static s32 ixgbevf_init_mbx_params_vf(struct ixgbe_hw *hw)
 {
         struct ixgbe_mbx_info *mbx = &hw->mbx;
 
diff --git a/drivers/net/ixgbevf/mbx.h b/drivers/net/ixgbevf/mbx.h
index 1b0e0bf4c0f5..ea393eb03f3a 100644
--- a/drivers/net/ixgbevf/mbx.h
+++ b/drivers/net/ixgbevf/mbx.h
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 82599 Virtual Function driver
-  Copyright(c) 1999 - 2009 Intel Corporation.
+  Copyright(c) 1999 - 2010 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -81,6 +81,7 @@
 #define IXGBE_VF_SET_MULTICAST    0x03 /* VF requests PF to set MC addr */
 #define IXGBE_VF_SET_VLAN         0x04 /* VF requests PF to set VLAN */
 #define IXGBE_VF_SET_LPE          0x05 /* VF requests PF to set VMOLR.LPE */
+#define IXGBE_VF_SET_MACVLAN      0x06 /* VF requests PF for unicast filter */
 
 /* length of permanent address message returned from PF */
 #define IXGBE_VF_PERMADDR_MSG_LEN 4
@@ -95,6 +96,4 @@
 /* forward declaration of the HW struct */
 struct ixgbe_hw;
 
-s32 ixgbevf_init_mbx_params_vf(struct ixgbe_hw *);
-
 #endif /* _IXGBE_MBX_H_ */
diff --git a/drivers/net/ixgbevf/regs.h b/drivers/net/ixgbevf/regs.h
index 12f75960aec1..189200eeca26 100644
--- a/drivers/net/ixgbevf/regs.h
+++ b/drivers/net/ixgbevf/regs.h
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 82599 Virtual Function driver
-  Copyright(c) 1999 - 2009 Intel Corporation.
+  Copyright(c) 1999 - 2010 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -31,7 +31,7 @@
 #define IXGBE_VFCTRL           0x00000
 #define IXGBE_VFSTATUS         0x00008
 #define IXGBE_VFLINKS          0x00010
-#define IXGBE_VFRTIMER         0x00048
+#define IXGBE_VFFRTIMER        0x00048
 #define IXGBE_VFRXMEMWRAP      0x03190
 #define IXGBE_VTEICR           0x00100
 #define IXGBE_VTEICS           0x00104
diff --git a/drivers/net/ixgbevf/vf.c b/drivers/net/ixgbevf/vf.c
index f6f929958ba0..aa3682e8c473 100644
--- a/drivers/net/ixgbevf/vf.c
+++ b/drivers/net/ixgbevf/vf.c
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 82599 Virtual Function driver
-  Copyright(c) 1999 - 2009 Intel Corporation.
+  Copyright(c) 1999 - 2010 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -216,6 +216,39 @@ static s32 ixgbevf_get_mac_addr_vf(struct ixgbe_hw *hw, u8 *mac_addr)
         return 0;
 }
 
+static s32 ixgbevf_set_uc_addr_vf(struct ixgbe_hw *hw, u32 index, u8 *addr)
+{
+        struct ixgbe_mbx_info *mbx = &hw->mbx;
+        u32 msgbuf[3];
+        u8 *msg_addr = (u8 *)(&msgbuf[1]);
+        s32 ret_val;
+
+        memset(msgbuf, 0, sizeof(msgbuf));
+        /*
+         * If index is one then this is the start of a new list and needs
+         * indication to the PF so it can do it's own list management.
+         * If it is zero then that tells the PF to just clear all of
+         * this VF's macvlans and there is no new list.
+         */
+        msgbuf[0] |= index << IXGBE_VT_MSGINFO_SHIFT;
+        msgbuf[0] |= IXGBE_VF_SET_MACVLAN;
+        if (addr)
+                memcpy(msg_addr, addr, 6);
+        ret_val = mbx->ops.write_posted(hw, msgbuf, 3);
+
+        if (!ret_val)
+                ret_val = mbx->ops.read_posted(hw, msgbuf, 3);
+
+        msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS;
+
+        if (!ret_val)
+                if (msgbuf[0] ==
+                    (IXGBE_VF_SET_MACVLAN | IXGBE_VT_MSGTYPE_NACK))
+                        ret_val = -ENOMEM;
+
+        return ret_val;
+}
+
 /**
  *  ixgbevf_set_rar_vf - set device MAC address
  *  @hw: pointer to hardware structure
@@ -368,7 +401,7 @@ static s32 ixgbevf_check_mac_link_vf(struct ixgbe_hw *hw,
         return 0;
 }
 
-struct ixgbe_mac_operations ixgbevf_mac_ops = {
+static struct ixgbe_mac_operations ixgbevf_mac_ops = {
         .init_hw             = ixgbevf_init_hw_vf,
         .reset_hw            = ixgbevf_reset_hw_vf,
         .start_hw            = ixgbevf_start_hw_vf,
@@ -378,11 +411,16 @@ struct ixgbe_mac_operations ixgbevf_mac_ops = {
         .check_link          = ixgbevf_check_mac_link_vf,
         .set_rar             = ixgbevf_set_rar_vf,
         .update_mc_addr_list = ixgbevf_update_mc_addr_list_vf,
+        .set_uc_addr         = ixgbevf_set_uc_addr_vf,
         .set_vfta            = ixgbevf_set_vfta_vf,
 };
 
-struct ixgbevf_info ixgbevf_vf_info = {
+struct ixgbevf_info ixgbevf_82599_vf_info = {
         .mac = ixgbe_mac_82599_vf,
         .mac_ops = &ixgbevf_mac_ops,
 };
 
+struct ixgbevf_info ixgbevf_X540_vf_info = {
+        .mac = ixgbe_mac_X540_vf,
+        .mac_ops = &ixgbevf_mac_ops,
+};
diff --git a/drivers/net/ixgbevf/vf.h b/drivers/net/ixgbevf/vf.h
index 94b750b8874f..10306b492ee6 100644
--- a/drivers/net/ixgbevf/vf.h
+++ b/drivers/net/ixgbevf/vf.h
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 82599 Virtual Function driver
-  Copyright(c) 1999 - 2009 Intel Corporation.
+  Copyright(c) 1999 - 2010 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -62,6 +62,7 @@ struct ixgbe_mac_operations {
 
         /* RAR, Multicast, VLAN */
         s32 (*set_rar)(struct ixgbe_hw *, u32, u8 *, u32);
+        s32 (*set_uc_addr)(struct ixgbe_hw *, u32, u8 *);
         s32 (*init_rx_addrs)(struct ixgbe_hw *);
         s32 (*update_mc_addr_list)(struct ixgbe_hw *, struct net_device *);
         s32 (*enable_mc)(struct ixgbe_hw *);
@@ -73,6 +74,7 @@ struct ixgbe_mac_operations {
 enum ixgbe_mac_type {
         ixgbe_mac_unknown = 0,
         ixgbe_mac_82599_vf,
+        ixgbe_mac_X540_vf,
         ixgbe_num_macs
 };
 
@@ -124,8 +126,6 @@ struct ixgbe_hw {
         void *back;
 
         u8 __iomem *hw_addr;
-        u8 *flash_address;
-        unsigned long io_base;
 
         struct ixgbe_mac_info mac;
         struct ixgbe_mbx_info mbx;