Patched in Tegra support.

3 files changed, 128 insertions, 133 deletions

diff --git a/drivers/net/vmxnet3/vmxnet3_drv.c b/drivers/net/vmxnet3/vmxnet3_drv.c
index dc8913c6238..0959583feb2 100644
--- a/drivers/net/vmxnet3/vmxnet3_drv.c
+++ b/drivers/net/vmxnet3/vmxnet3_drv.c
@@ -24,7 +24,6 @@
  *
  */
 
-#include <linux/module.h>
 #include <net/ip6_checksum.h>
 
 #include "vmxnet3_int.h"
@@ -537,8 +536,11 @@ vmxnet3_tq_create(struct vmxnet3_tx_queue *tq,
 
         tq->buf_info = kcalloc(tq->tx_ring.size, sizeof(tq->buf_info[0]),
                                GFP_KERNEL);
-        if (!tq->buf_info)
+        if (!tq->buf_info) {
+                printk(KERN_ERR "%s: failed to allocate tx bufinfo\n",
+                       adapter->netdev->name);
                 goto err;
+        }
 
         return 0;
 
@@ -633,7 +635,7 @@ vmxnet3_rq_alloc_rx_buf(struct vmxnet3_rx_queue *rq, u32 ring_idx,
 
         dev_dbg(&adapter->netdev->dev,
                 "alloc_rx_buf: %d allocated, next2fill %u, next2comp "
-                "%u, uncommitted %u\n", num_allocated, ring->next2fill,
+                "%u, uncommited %u\n", num_allocated, ring->next2fill,
                 ring->next2comp, rq->uncommitted[ring_idx]);
 
         /* so that the device can distinguish a full ring and an empty ring */
@@ -652,11 +654,10 @@ vmxnet3_append_frag(struct sk_buff *skb, struct Vmxnet3_RxCompDesc *rcd,
 
         BUG_ON(skb_shinfo(skb)->nr_frags >= MAX_SKB_FRAGS);
 
-        __skb_frag_set_page(frag, rbi->page);
+        frag->page = rbi->page;
         frag->page_offset = 0;
-        skb_frag_size_set(frag, rcd->len);
-        skb->data_len += rcd->len;
-        skb->truesize += PAGE_SIZE;
+        frag->size = rcd->len;
+        skb->data_len += frag->size;
         skb_shinfo(skb)->nr_frags++;
 }
 
@@ -743,44 +744,29 @@ vmxnet3_map_pkt(struct sk_buff *skb, struct vmxnet3_tx_ctx *ctx,
         }
 
         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
-                const struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i];
-                u32 buf_size;
+                struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i];
 
-                buf_offset = 0;
-                len = skb_frag_size(frag);
-                while (len) {
-                        tbi = tq->buf_info + tq->tx_ring.next2fill;
-                        if (len < VMXNET3_MAX_TX_BUF_SIZE) {
-                                buf_size = len;
-                                dw2 |= len;
-                        } else {
-                                buf_size = VMXNET3_MAX_TX_BUF_SIZE;
-                                /* spec says that for TxDesc.len, 0 == 2^14 */
-                        }
-                        tbi->map_type = VMXNET3_MAP_PAGE;
-                        tbi->dma_addr = skb_frag_dma_map(&adapter->pdev->dev, frag,
-                                                         buf_offset, buf_size,
-                                                         DMA_TO_DEVICE);
-
-                        tbi->len = buf_size;
+                tbi = tq->buf_info + tq->tx_ring.next2fill;
+                tbi->map_type = VMXNET3_MAP_PAGE;
+                tbi->dma_addr = pci_map_page(adapter->pdev, frag->page,
+                                             frag->page_offset, frag->size,
+                                             PCI_DMA_TODEVICE);
 
-                        gdesc = tq->tx_ring.base + tq->tx_ring.next2fill;
-                        BUG_ON(gdesc->txd.gen == tq->tx_ring.gen);
+                tbi->len = frag->size;
 
-                        gdesc->txd.addr = cpu_to_le64(tbi->dma_addr);
-                        gdesc->dword[2] = cpu_to_le32(dw2);
-                        gdesc->dword[3] = 0;
+                gdesc = tq->tx_ring.base + tq->tx_ring.next2fill;
+                BUG_ON(gdesc->txd.gen == tq->tx_ring.gen);
 
-                        dev_dbg(&adapter->netdev->dev,
-                                "txd[%u]: 0x%llu %u %u\n",
-                                tq->tx_ring.next2fill, le64_to_cpu(gdesc->txd.addr),
-                                le32_to_cpu(gdesc->dword[2]), gdesc->dword[3]);
-                        vmxnet3_cmd_ring_adv_next2fill(&tq->tx_ring);
-                        dw2 = tq->tx_ring.gen << VMXNET3_TXD_GEN_SHIFT;
+                gdesc->txd.addr = cpu_to_le64(tbi->dma_addr);
+                gdesc->dword[2] = cpu_to_le32(dw2 | frag->size);
+                gdesc->dword[3] = 0;
 
-                        len -= buf_size;
-                        buf_offset += buf_size;
-                }
+                dev_dbg(&adapter->netdev->dev,
+                        "txd[%u]: 0x%llu %u %u\n",
+                        tq->tx_ring.next2fill, le64_to_cpu(gdesc->txd.addr),
+                        le32_to_cpu(gdesc->dword[2]), gdesc->dword[3]);
+                vmxnet3_cmd_ring_adv_next2fill(&tq->tx_ring);
+                dw2 = tq->tx_ring.gen << VMXNET3_TXD_GEN_SHIFT;
         }
 
         ctx->eop_txd = gdesc;
@@ -828,27 +814,35 @@ vmxnet3_parse_and_copy_hdr(struct sk_buff *skb, struct vmxnet3_tx_queue *tq,
 
         if (ctx->mss) { /* TSO */
                 ctx->eth_ip_hdr_size = skb_transport_offset(skb);
-                ctx->l4_hdr_size = tcp_hdrlen(skb);
+                ctx->l4_hdr_size = ((struct tcphdr *)
+                                   skb_transport_header(skb))->doff * 4;
                 ctx->copy_size = ctx->eth_ip_hdr_size + ctx->l4_hdr_size;
         } else {
                 if (skb->ip_summed == CHECKSUM_PARTIAL) {
                         ctx->eth_ip_hdr_size = skb_checksum_start_offset(skb);
 
                         if (ctx->ipv4) {
-                                const struct iphdr *iph = ip_hdr(skb);
-
+                                struct iphdr *iph = (struct iphdr *)
+                                                    skb_network_header(skb);
                                 if (iph->protocol == IPPROTO_TCP)
-                                        ctx->l4_hdr_size = tcp_hdrlen(skb);
+                                        ctx->l4_hdr_size = ((struct tcphdr *)
+                                           skb_transport_header(skb))->doff * 4;
                                 else if (iph->protocol == IPPROTO_UDP)
-                                        ctx->l4_hdr_size = sizeof(struct udphdr);
+                                        /*
+                                         * Use tcp header size so that bytes to
+                                         * be copied are more than required by
+                                         * the device.
+                                         */
+                                        ctx->l4_hdr_size =
+                                                        sizeof(struct tcphdr);
                                 else
                                         ctx->l4_hdr_size = 0;
                         } else {
                                 /* for simplicity, don't copy L4 headers */
                                 ctx->l4_hdr_size = 0;
                         }
-                        ctx->copy_size = min(ctx->eth_ip_hdr_size +
-                                         ctx->l4_hdr_size, skb->len);
+                        ctx->copy_size = ctx->eth_ip_hdr_size +
+                                         ctx->l4_hdr_size;
                 } else {
                         ctx->eth_ip_hdr_size = 0;
                         ctx->l4_hdr_size = 0;
@@ -885,34 +879,19 @@ static void
 vmxnet3_prepare_tso(struct sk_buff *skb,
                     struct vmxnet3_tx_ctx *ctx)
 {
-        struct tcphdr *tcph = tcp_hdr(skb);
-
+        struct tcphdr *tcph = (struct tcphdr *)skb_transport_header(skb);
         if (ctx->ipv4) {
-                struct iphdr *iph = ip_hdr(skb);
-
+                struct iphdr *iph = (struct iphdr *)skb_network_header(skb);
                 iph->check = 0;
                 tcph->check = ~csum_tcpudp_magic(iph->saddr, iph->daddr, 0,
                                                  IPPROTO_TCP, 0);
         } else {
-                struct ipv6hdr *iph = ipv6_hdr(skb);
-
+                struct ipv6hdr *iph = (struct ipv6hdr *)skb_network_header(skb);
                 tcph->check = ~csum_ipv6_magic(&iph->saddr, &iph->daddr, 0,
                                                IPPROTO_TCP, 0);
         }
 }
 
-static int txd_estimate(const struct sk_buff *skb)
-{
-        int count = VMXNET3_TXD_NEEDED(skb_headlen(skb)) + 1;
-        int i;
-
-        for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
-                const struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i];
-
-                count += VMXNET3_TXD_NEEDED(skb_frag_size(frag));
-        }
-        return count;
-}
 
 /*
  * Transmits a pkt thru a given tq
@@ -941,7 +920,9 @@ vmxnet3_tq_xmit(struct sk_buff *skb, struct vmxnet3_tx_queue *tq,
         union Vmxnet3_GenericDesc tempTxDesc;
 #endif
 
-        count = txd_estimate(skb);
+        /* conservatively estimate # of descriptors to use */
+        count = VMXNET3_TXD_NEEDED(skb_headlen(skb)) +
+                skb_shinfo(skb)->nr_frags + 1;
 
         ctx.ipv4 = (vlan_get_protocol(skb) == cpu_to_be16(ETH_P_IP));
 
@@ -1062,7 +1043,7 @@ vmxnet3_tq_xmit(struct sk_buff *skb, struct vmxnet3_tx_queue *tq,
 #endif
         dev_dbg(&adapter->netdev->dev,
                 "txd[%u]: SOP 0x%Lx 0x%x 0x%x\n",
-                (u32)(ctx.sop_txd -
+                (u32)((union Vmxnet3_GenericDesc *)ctx.sop_txd -
                 tq->tx_ring.base), le64_to_cpu(gdesc->txd.addr),
                 le32_to_cpu(gdesc->dword[2]), le32_to_cpu(gdesc->dword[3]));
 
@@ -1094,10 +1075,10 @@ vmxnet3_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
 {
         struct vmxnet3_adapter *adapter = netdev_priv(netdev);
 
-        BUG_ON(skb->queue_mapping > adapter->num_tx_queues);
-        return vmxnet3_tq_xmit(skb,
-                               &adapter->tx_queue[skb->queue_mapping],
-                               adapter, netdev);
+                BUG_ON(skb->queue_mapping > adapter->num_tx_queues);
+                return vmxnet3_tq_xmit(skb,
+                                       &adapter->tx_queue[skb->queue_mapping],
+                                       adapter, netdev);
 }
 
 
@@ -1243,8 +1224,8 @@ vmxnet3_rq_rx_complete(struct vmxnet3_rx_queue *rq,
                         skb_reserve(new_skb, NET_IP_ALIGN);
                         rbi->skb = new_skb;
                         rbi->dma_addr = pci_map_single(adapter->pdev,
-                                                       rbi->skb->data, rbi->len,
-                                                       PCI_DMA_FROMDEVICE);
+                                        rbi->skb->data, rbi->len,
+                                        PCI_DMA_FROMDEVICE);
                         rxd->addr = cpu_to_le64(rbi->dma_addr);
                         rxd->len = rbi->len;
 
@@ -1296,6 +1277,7 @@ vmxnet3_rq_rx_complete(struct vmxnet3_rx_queue *rq,
                 skb = ctx->skb;
                 if (rcd->eop) {
                         skb->len += skb->data_len;
+                        skb->truesize += skb->data_len;
 
                         vmxnet3_rx_csum(adapter, skb,
                                         (union Vmxnet3_GenericDesc *)rcd);
@@ -1331,14 +1313,14 @@ rcd_done:
                 /* if needed, update the register */
                 if (unlikely(rq->shared->updateRxProd)) {
                         VMXNET3_WRITE_BAR0_REG(adapter,
-                                               rxprod_reg[ring_idx] + rq->qid * 8,
-                                               ring->next2fill);
+                                rxprod_reg[ring_idx] + rq->qid * 8,
+                                ring->next2fill);
                         rq->uncommitted[ring_idx] = 0;
                 }
 
                 vmxnet3_comp_ring_adv_next2proc(&rq->comp_ring);
                 vmxnet3_getRxComp(rcd,
-                                  &rq->comp_ring.base[rq->comp_ring.next2proc].rcd, &rxComp);
+                     &rq->comp_ring.base[rq->comp_ring.next2proc].rcd, &rxComp);
         }
 
         return num_rxd;
@@ -1536,9 +1518,11 @@ vmxnet3_rq_create(struct vmxnet3_rx_queue *rq, struct vmxnet3_adapter *adapter)
         sz = sizeof(struct vmxnet3_rx_buf_info) * (rq->rx_ring[0].size +
                                                    rq->rx_ring[1].size);
         bi = kzalloc(sz, GFP_KERNEL);
-        if (!bi)
+        if (!bi) {
+                printk(KERN_ERR "%s: failed to allocate rx bufinfo\n",
+                       adapter->netdev->name);
                 goto err;
-
+        }
         rq->buf_info[0] = bi;
         rq->buf_info[1] = bi + rq->rx_ring[0].size;
 
@@ -1922,7 +1906,7 @@ vmxnet3_free_irqs(struct vmxnet3_adapter *adapter)
                 free_irq(adapter->pdev->irq, adapter->netdev);
                 break;
         default:
-                BUG();
+                BUG_ON(true);
         }
 }
 
@@ -1941,7 +1925,7 @@ vmxnet3_restore_vlan(struct vmxnet3_adapter *adapter)
 }
 
 
-static int
+static void
 vmxnet3_vlan_rx_add_vid(struct net_device *netdev, u16 vid)
 {
         struct vmxnet3_adapter *adapter = netdev_priv(netdev);
@@ -1958,12 +1942,10 @@ vmxnet3_vlan_rx_add_vid(struct net_device *netdev, u16 vid)
         }
 
         set_bit(vid, adapter->active_vlans);
-
-        return 0;
 }
 
 
-static int
+static void
 vmxnet3_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
 {
         struct vmxnet3_adapter *adapter = netdev_priv(netdev);
@@ -1980,8 +1962,6 @@ vmxnet3_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
         }
 
         clear_bit(vid, adapter->active_vlans);
-
-        return 0;
 }
 
 
@@ -2182,8 +2162,7 @@ vmxnet3_setup_driver_shared(struct vmxnet3_adapter *adapter)
                 rssConf->indTableSize = VMXNET3_RSS_IND_TABLE_SIZE;
                 get_random_bytes(&rssConf->hashKey[0], rssConf->hashKeySize);
                 for (i = 0; i < rssConf->indTableSize; i++)
-                        rssConf->indTable[i] = ethtool_rxfh_indir_default(
-                                i, adapter->num_rx_queues);
+                        rssConf->indTable[i] = i % adapter->num_rx_queues;
 
                 devRead->rssConfDesc.confVer = 1;
                 devRead->rssConfDesc.confLen = sizeof(*rssConf);
@@ -2724,8 +2703,8 @@ vmxnet3_acquire_msix_vectors(struct vmxnet3_adapter *adapter,
                         adapter->intr.num_intrs = vectors;
                         return 0;
                 } else if (err < 0) {
-                        netdev_err(adapter->netdev,
-                                   "Failed to enable MSI-X, error: %d\n", err);
+                        printk(KERN_ERR "Failed to enable MSI-X for %s, error"
+                               " %d\n", adapter->netdev->name, err);
                         vectors = 0;
                 } else if (err < vector_threshold) {
                         break;
@@ -2733,15 +2712,15 @@ vmxnet3_acquire_msix_vectors(struct vmxnet3_adapter *adapter,
                         /* If fails to enable required number of MSI-x vectors
                          * try enabling minimum number of vectors required.
                          */
-                        netdev_err(adapter->netdev,
-                                   "Failed to enable %d MSI-X, trying %d instead\n",
-                                    vectors, vector_threshold);
                         vectors = vector_threshold;
+                        printk(KERN_ERR "Failed to enable %d MSI-X for %s, try"
+                               " %d instead\n", vectors, adapter->netdev->name,
+                               vector_threshold);
                 }
         }
 
-        netdev_info(adapter->netdev,
-                    "Number of MSI-X interrupts which can be allocated are lower than min threshold required.\n");
+        printk(KERN_INFO "Number of MSI-X interrupts which can be allocatedi"
+               " are lower than min threshold required.\n");
         return err;
 }
 
@@ -2807,9 +2786,8 @@ vmxnet3_alloc_intr_resources(struct vmxnet3_adapter *adapter)
                         return;
 
                 /* If we cannot allocate MSIx vectors use only one rx queue */
-                netdev_info(adapter->netdev,
-                            "Failed to enable MSI-X, error %d . Limiting #rx queues to 1, try MSI.\n",
-                            err);
+                printk(KERN_INFO "Failed to enable MSI-X for %s, error %d."
+                       "#rx queues : 1, try MSI\n", adapter->netdev->name, err);
 
                 adapter->intr.type = VMXNET3_IT_MSI;
         }
@@ -2885,7 +2863,7 @@ vmxnet3_reset_work(struct work_struct *data)
 }
 
 
-static int
+static int __devinit
 vmxnet3_probe_device(struct pci_dev *pdev,
                      const struct pci_device_id *id)
 {
@@ -2898,7 +2876,7 @@ vmxnet3_probe_device(struct pci_dev *pdev,
                 .ndo_set_features = vmxnet3_set_features,
                 .ndo_get_stats64 = vmxnet3_get_stats64,
                 .ndo_tx_timeout = vmxnet3_tx_timeout,
-                .ndo_set_rx_mode = vmxnet3_set_mc,
+                .ndo_set_multicast_list = vmxnet3_set_mc,
                 .ndo_vlan_rx_add_vid = vmxnet3_vlan_rx_add_vid,
                 .ndo_vlan_rx_kill_vid = vmxnet3_vlan_rx_kill_vid,
 #ifdef CONFIG_NET_POLL_CONTROLLER
@@ -2939,8 +2917,11 @@ vmxnet3_probe_device(struct pci_dev *pdev,
         printk(KERN_INFO "# of Tx queues : %d, # of Rx queues : %d\n",
                num_tx_queues, num_rx_queues);
 
-        if (!netdev)
+        if (!netdev) {
+                printk(KERN_ERR "Failed to alloc ethernet device for adapter "
+                        "%s\n", pci_name(pdev));
                 return -ENOMEM;
+        }
 
         pci_set_drvdata(pdev, netdev);
         adapter = netdev_priv(netdev);
@@ -2949,11 +2930,11 @@ vmxnet3_probe_device(struct pci_dev *pdev,
 
         spin_lock_init(&adapter->cmd_lock);
         adapter->shared = pci_alloc_consistent(adapter->pdev,
-                                               sizeof(struct Vmxnet3_DriverShared),
-                                               &adapter->shared_pa);
+                          sizeof(struct Vmxnet3_DriverShared),
+                          &adapter->shared_pa);
         if (!adapter->shared) {
                 printk(KERN_ERR "Failed to allocate memory for %s\n",
-                       pci_name(pdev));
+                        pci_name(pdev));
                 err = -ENOMEM;
                 goto err_alloc_shared;
         }
@@ -2964,19 +2945,21 @@ vmxnet3_probe_device(struct pci_dev *pdev,
         size = sizeof(struct Vmxnet3_TxQueueDesc) * adapter->num_tx_queues;
         size += sizeof(struct Vmxnet3_RxQueueDesc) * adapter->num_rx_queues;
         adapter->tqd_start = pci_alloc_consistent(adapter->pdev, size,
-                                                  &adapter->queue_desc_pa);
+                             &adapter->queue_desc_pa);
 
         if (!adapter->tqd_start) {
                 printk(KERN_ERR "Failed to allocate memory for %s\n",
-                       pci_name(pdev));
+                        pci_name(pdev));
                 err = -ENOMEM;
                 goto err_alloc_queue_desc;
         }
         adapter->rqd_start = (struct Vmxnet3_RxQueueDesc *)(adapter->tqd_start +
-                                                            adapter->num_tx_queues);
+                                                        adapter->num_tx_queues);
 
         adapter->pm_conf = kmalloc(sizeof(struct Vmxnet3_PMConf), GFP_KERNEL);
         if (adapter->pm_conf == NULL) {
+                printk(KERN_ERR "Failed to allocate memory for %s\n",
+                        pci_name(pdev));
                 err = -ENOMEM;
                 goto err_alloc_pm;
         }
@@ -2985,6 +2968,8 @@ vmxnet3_probe_device(struct pci_dev *pdev,
 
         adapter->rss_conf = kmalloc(sizeof(struct UPT1_RSSConf), GFP_KERNEL);
         if (adapter->rss_conf == NULL) {
+                printk(KERN_ERR "Failed to allocate memory for %s\n",
+                       pci_name(pdev));
                 err = -ENOMEM;
                 goto err_alloc_rss;
         }
@@ -3019,7 +3004,7 @@ vmxnet3_probe_device(struct pci_dev *pdev,
 
         adapter->dev_number = atomic_read(&devices_found);
 
-        adapter->share_intr = irq_share_mode;
+         adapter->share_intr = irq_share_mode;
         if (adapter->share_intr == VMXNET3_INTR_BUDDYSHARE &&
             adapter->num_tx_queues != adapter->num_rx_queues)
                 adapter->share_intr = VMXNET3_INTR_DONTSHARE;
@@ -3044,7 +3029,6 @@ vmxnet3_probe_device(struct pci_dev *pdev,
         netdev->watchdog_timeo = 5 * HZ;
 
         INIT_WORK(&adapter->work, vmxnet3_reset_work);
-        set_bit(VMXNET3_STATE_BIT_QUIESCED, &adapter->state);
 
         if (adapter->intr.type == VMXNET3_IT_MSIX) {
                 int i;
@@ -3065,10 +3049,11 @@ vmxnet3_probe_device(struct pci_dev *pdev,
 
         if (err) {
                 printk(KERN_ERR "Failed to register adapter %s\n",
-                       pci_name(pdev));
+                        pci_name(pdev));
                 goto err_register;
         }
 
+        set_bit(VMXNET3_STATE_BIT_QUIESCED, &adapter->state);
         vmxnet3_check_link(adapter, false);
         atomic_inc(&devices_found);
         return 0;
@@ -3096,7 +3081,7 @@ err_alloc_shared:
 }
 
 
-static void
+static void __devexit
 vmxnet3_remove_device(struct pci_dev *pdev)
 {
         struct net_device *netdev = pci_get_drvdata(pdev);
@@ -3302,7 +3287,7 @@ static struct pci_driver vmxnet3_driver = {
         .name           = vmxnet3_driver_name,
         .id_table       = vmxnet3_pciid_table,
         .probe          = vmxnet3_probe_device,
-        .remove         = vmxnet3_remove_device,
+        .remove         = __devexit_p(vmxnet3_remove_device),
 #ifdef CONFIG_PM
         .driver.pm      = &vmxnet3_pm_ops,
 #endif
diff --git a/drivers/net/vmxnet3/vmxnet3_ethtool.c b/drivers/net/vmxnet3/vmxnet3_ethtool.c
index 587a218b234..27400edeef5 100644
--- a/drivers/net/vmxnet3/vmxnet3_ethtool.c
+++ b/drivers/net/vmxnet3/vmxnet3_ethtool.c
@@ -202,9 +202,14 @@ vmxnet3_get_drvinfo(struct net_device *netdev, struct ethtool_drvinfo *drvinfo)
         struct vmxnet3_adapter *adapter = netdev_priv(netdev);
 
         strlcpy(drvinfo->driver, vmxnet3_driver_name, sizeof(drvinfo->driver));
+        drvinfo->driver[sizeof(drvinfo->driver) - 1] = '\0';
 
         strlcpy(drvinfo->version, VMXNET3_DRIVER_VERSION_REPORT,
                 sizeof(drvinfo->version));
+        drvinfo->driver[sizeof(drvinfo->version) - 1] = '\0';
+
+        strlcpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version));
+        drvinfo->fw_version[sizeof(drvinfo->fw_version) - 1] = '\0';
 
         strlcpy(drvinfo->bus_info, pci_name(adapter->pdev),
                 ETHTOOL_BUSINFO_LEN);
@@ -257,11 +262,11 @@ vmxnet3_get_strings(struct net_device *netdev, u32 stringset, u8 *buf)
         }
 }
 
-int vmxnet3_set_features(struct net_device *netdev, netdev_features_t features)
+int vmxnet3_set_features(struct net_device *netdev, u32 features)
 {
         struct vmxnet3_adapter *adapter = netdev_priv(netdev);
         unsigned long flags;
-        netdev_features_t changed = features ^ netdev->features;
+        u32 changed = features ^ netdev->features;
 
         if (changed & (NETIF_F_RXCSUM | NETIF_F_LRO | NETIF_F_HW_VLAN_RX)) {
                 if (features & NETIF_F_RXCSUM)
@@ -553,7 +558,7 @@ out:
 
 static int
 vmxnet3_get_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *info,
-                  u32 *rules)
+                  void *rules)
 {
         struct vmxnet3_adapter *adapter = netdev_priv(netdev);
         switch (info->cmd) {
@@ -565,38 +570,44 @@ vmxnet3_get_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *info,
 }
 
 #ifdef VMXNET3_RSS
-static u32
-vmxnet3_get_rss_indir_size(struct net_device *netdev)
-{
-        struct vmxnet3_adapter *adapter = netdev_priv(netdev);
-        struct UPT1_RSSConf *rssConf = adapter->rss_conf;
-
-        return rssConf->indTableSize;
-}
-
 static int
-vmxnet3_get_rss_indir(struct net_device *netdev, u32 *p)
+vmxnet3_get_rss_indir(struct net_device *netdev,
+                      struct ethtool_rxfh_indir *p)
 {
         struct vmxnet3_adapter *adapter = netdev_priv(netdev);
         struct UPT1_RSSConf *rssConf = adapter->rss_conf;
-        unsigned int n = rssConf->indTableSize;
+        unsigned int n = min_t(unsigned int, p->size, rssConf->indTableSize);
 
+        p->size = rssConf->indTableSize;
         while (n--)
-                p[n] = rssConf->indTable[n];
+                p->ring_index[n] = rssConf->indTable[n];
         return 0;
 
 }
 
 static int
-vmxnet3_set_rss_indir(struct net_device *netdev, const u32 *p)
+vmxnet3_set_rss_indir(struct net_device *netdev,
+                      const struct ethtool_rxfh_indir *p)
 {
         unsigned int i;
         unsigned long flags;
         struct vmxnet3_adapter *adapter = netdev_priv(netdev);
         struct UPT1_RSSConf *rssConf = adapter->rss_conf;
 
+        if (p->size != rssConf->indTableSize)
+                return -EINVAL;
+        for (i = 0; i < rssConf->indTableSize; i++) {
+                /*
+                 * Return with error code if any of the queue indices
+                 * is out of range
+                 */
+                if (p->ring_index[i] < 0 ||
+                    p->ring_index[i] >= adapter->num_rx_queues)
+                        return -EINVAL;
+        }
+
         for (i = 0; i < rssConf->indTableSize; i++)
-                rssConf->indTable[i] = p[i];
+                rssConf->indTable[i] = p->ring_index[i];
 
         spin_lock_irqsave(&adapter->cmd_lock, flags);
         VMXNET3_WRITE_BAR1_REG(adapter, VMXNET3_REG_CMD,
@@ -608,7 +619,7 @@ vmxnet3_set_rss_indir(struct net_device *netdev, const u32 *p)
 }
 #endif
 
-static const struct ethtool_ops vmxnet3_ethtool_ops = {
+static struct ethtool_ops vmxnet3_ethtool_ops = {
         .get_settings      = vmxnet3_get_settings,
         .get_drvinfo       = vmxnet3_get_drvinfo,
         .get_regs_len      = vmxnet3_get_regs_len,
@@ -623,7 +634,6 @@ static const struct ethtool_ops vmxnet3_ethtool_ops = {
         .set_ringparam     = vmxnet3_set_ringparam,
         .get_rxnfc         = vmxnet3_get_rxnfc,
 #ifdef VMXNET3_RSS
-        .get_rxfh_indir_size = vmxnet3_get_rss_indir_size,
         .get_rxfh_indir    = vmxnet3_get_rss_indir,
         .set_rxfh_indir    = vmxnet3_set_rss_indir,
 #endif
diff --git a/drivers/net/vmxnet3/vmxnet3_int.h b/drivers/net/vmxnet3/vmxnet3_int.h
index fc46a81ad53..b18eac1dcca 100644
--- a/drivers/net/vmxnet3/vmxnet3_int.h
+++ b/drivers/net/vmxnet3/vmxnet3_int.h
@@ -70,10 +70,10 @@
 /*
  * Version numbers
  */
-#define VMXNET3_DRIVER_VERSION_STRING   "1.1.29.0-k"
+#define VMXNET3_DRIVER_VERSION_STRING   "1.1.18.0-k"
 
 /* a 32-bit int, each byte encode a verion number in VMXNET3_DRIVER_VERSION */
-#define VMXNET3_DRIVER_VERSION_NUM      0x01011D00
+#define VMXNET3_DRIVER_VERSION_NUM      0x01011200
 
 #if defined(CONFIG_PCI_MSI)
         /* RSS only makes sense if MSI-X is supported. */
@@ -401,7 +401,7 @@ void
 vmxnet3_rq_destroy_all(struct vmxnet3_adapter *adapter);
 
 int
-vmxnet3_set_features(struct net_device *netdev, netdev_features_t features);
+vmxnet3_set_features(struct net_device *netdev, u32 features);
 
 int
 vmxnet3_create_queues(struct vmxnet3_adapter *adapter,