1 files changed, 208 insertions, 178 deletions

diff --git a/drivers/net/sfc/ethtool.c b/drivers/net/sfc/ethtool.c
index fd19d6ab97a2..d229027dc363 100644
--- a/drivers/net/sfc/ethtool.c
+++ b/drivers/net/sfc/ethtool.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * Driver for Solarflare Solarstorm network controllers and boards
  * Copyright 2005-2006 Fen Systems Ltd.
- * Copyright 2006-2009 Solarflare Communications Inc.
+ * Copyright 2006-2010 Solarflare Communications Inc.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 as published
@@ -11,13 +11,13 @@
 #include <linux/netdevice.h>
 #include <linux/ethtool.h>
 #include <linux/rtnetlink.h>
+#include <linux/in.h>
 #include "net_driver.h"
 #include "workarounds.h"
 #include "selftest.h"
 #include "efx.h"
+#include "filter.h"
 #include "nic.h"
-#include "spi.h"
-#include "mdio_10g.h"
 
 struct ethtool_string {
         char name[ETH_GSTRING_LEN];
@@ -28,7 +28,8 @@ struct efx_ethtool_stat {
         enum {
                 EFX_ETHTOOL_STAT_SOURCE_mac_stats,
                 EFX_ETHTOOL_STAT_SOURCE_nic,
-                EFX_ETHTOOL_STAT_SOURCE_channel
+                EFX_ETHTOOL_STAT_SOURCE_channel,
+                EFX_ETHTOOL_STAT_SOURCE_tx_queue
         } source;
         unsigned offset;
         u64(*get_stat) (void *field); /* Reader function */
@@ -86,6 +87,10 @@ static u64 efx_get_atomic_stat(void *field)
         EFX_ETHTOOL_STAT(field, channel, n_##field,             \
                          unsigned int, efx_get_uint_stat)
 
+#define EFX_ETHTOOL_UINT_TXQ_STAT(field)                        \
+        EFX_ETHTOOL_STAT(tx_##field, tx_queue, field,           \
+                         unsigned int, efx_get_uint_stat)
+
 static struct efx_ethtool_stat efx_ethtool_stats[] = {
         EFX_ETHTOOL_U64_MAC_STAT(tx_bytes),
         EFX_ETHTOOL_U64_MAC_STAT(tx_good_bytes),
@@ -116,6 +121,10 @@ static struct efx_ethtool_stat efx_ethtool_stats[] = {
         EFX_ETHTOOL_ULONG_MAC_STAT(tx_non_tcpudp),
         EFX_ETHTOOL_ULONG_MAC_STAT(tx_mac_src_error),
         EFX_ETHTOOL_ULONG_MAC_STAT(tx_ip_src_error),
+        EFX_ETHTOOL_UINT_TXQ_STAT(tso_bursts),
+        EFX_ETHTOOL_UINT_TXQ_STAT(tso_long_headers),
+        EFX_ETHTOOL_UINT_TXQ_STAT(tso_packets),
+        EFX_ETHTOOL_UINT_TXQ_STAT(pushes),
         EFX_ETHTOOL_U64_MAC_STAT(rx_bytes),
         EFX_ETHTOOL_U64_MAC_STAT(rx_good_bytes),
         EFX_ETHTOOL_U64_MAC_STAT(rx_bad_bytes),
@@ -169,25 +178,33 @@ static struct efx_ethtool_stat efx_ethtool_stats[] = {
  */
 
 /* Identify device by flashing LEDs */
-static int efx_ethtool_phys_id(struct net_device *net_dev, u32 count)
+static int efx_ethtool_phys_id(struct net_device *net_dev,
+                               enum ethtool_phys_id_state state)
 {
         struct efx_nic *efx = netdev_priv(net_dev);
+        enum efx_led_mode mode = EFX_LED_DEFAULT;
 
-        do {
-                efx->type->set_id_led(efx, EFX_LED_ON);
-                schedule_timeout_interruptible(HZ / 2);
-
-                efx->type->set_id_led(efx, EFX_LED_OFF);
-                schedule_timeout_interruptible(HZ / 2);
-        } while (!signal_pending(current) && --count != 0);
+        switch (state) {
+        case ETHTOOL_ID_ON:
+                mode = EFX_LED_ON;
+                break;
+        case ETHTOOL_ID_OFF:
+                mode = EFX_LED_OFF;
+                break;
+        case ETHTOOL_ID_INACTIVE:
+                mode = EFX_LED_DEFAULT;
+                break;
+        case ETHTOOL_ID_ACTIVE:
+                return 1;       /* cycle on/off once per second */
+        }
 
-        efx->type->set_id_led(efx, EFX_LED_DEFAULT);
+        efx->type->set_id_led(efx, mode);
         return 0;
 }
 
 /* This must be called with rtnl_lock held. */
-int efx_ethtool_get_settings(struct net_device *net_dev,
-                             struct ethtool_cmd *ecmd)
+static int efx_ethtool_get_settings(struct net_device *net_dev,
+                                    struct ethtool_cmd *ecmd)
 {
         struct efx_nic *efx = netdev_priv(net_dev);
         struct efx_link_state *link_state = &efx->link_state;
@@ -202,7 +219,7 @@ int efx_ethtool_get_settings(struct net_device *net_dev,
         ecmd->supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
 
         if (LOOPBACK_INTERNAL(efx)) {
-                ecmd->speed = link_state->speed;
+                ethtool_cmd_speed_set(ecmd, link_state->speed);
                 ecmd->duplex = link_state->fd ? DUPLEX_FULL : DUPLEX_HALF;
         }
 
@@ -210,14 +227,15 @@ int efx_ethtool_get_settings(struct net_device *net_dev,
 }
 
 /* This must be called with rtnl_lock held. */
-int efx_ethtool_set_settings(struct net_device *net_dev,
-                             struct ethtool_cmd *ecmd)
+static int efx_ethtool_set_settings(struct net_device *net_dev,
+                                    struct ethtool_cmd *ecmd)
 {
         struct efx_nic *efx = netdev_priv(net_dev);
         int rc;
 
         /* GMAC does not support 1000Mbps HD */
-        if (ecmd->speed == SPEED_1000 && ecmd->duplex != DUPLEX_FULL) {
+        if ((ethtool_cmd_speed(ecmd) == SPEED_1000) &&
+            (ecmd->duplex != DUPLEX_FULL)) {
                 netif_dbg(efx, drv, efx->net_dev,
                           "rejecting unsupported 1000Mbps HD setting\n");
                 return -EINVAL;
@@ -237,8 +255,8 @@ static void efx_ethtool_get_drvinfo(struct net_device *net_dev,
         strlcpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
         strlcpy(info->version, EFX_DRIVER_VERSION, sizeof(info->version));
         if (efx_nic_rev(efx) >= EFX_REV_SIENA_A0)
-                siena_print_fwver(efx, info->fw_version,
-                                  sizeof(info->fw_version));
+                efx_mcdi_print_fwver(efx, info->fw_version,
+                                     sizeof(info->fw_version));
         strlcpy(info->bus_info, pci_name(efx->pci_dev), sizeof(info->bus_info));
 }
 
@@ -328,9 +346,10 @@ static int efx_fill_loopback_test(struct efx_nic *efx,
                                   unsigned int test_index,
                                   struct ethtool_string *strings, u64 *data)
 {
+        struct efx_channel *channel = efx_get_channel(efx, 0);
         struct efx_tx_queue *tx_queue;
 
-        efx_for_each_channel_tx_queue(tx_queue, &efx->channel[0]) {
+        efx_for_each_channel_tx_queue(tx_queue, channel) {
                 efx_fill_test(test_index++, strings, data,
                               &lb_tests->tx_sent[tx_queue->queue],
                               EFX_TX_QUEUE_NAME(tx_queue),
@@ -469,6 +488,7 @@ static void efx_ethtool_get_stats(struct net_device *net_dev,
         struct efx_mac_stats *mac_stats = &efx->mac_stats;
         struct efx_ethtool_stat *stat;
         struct efx_channel *channel;
+        struct efx_tx_queue *tx_queue;
         struct rtnl_link_stats64 temp;
         int i;
 
@@ -494,74 +514,31 @@ static void efx_ethtool_get_stats(struct net_device *net_dev,
                                 data[i] += stat->get_stat((void *)channel +
                                                           stat->offset);
                         break;
+                case EFX_ETHTOOL_STAT_SOURCE_tx_queue:
+                        data[i] = 0;
+                        efx_for_each_channel(channel, efx) {
+                                efx_for_each_channel_tx_queue(tx_queue, channel)
+                                        data[i] +=
+                                                stat->get_stat((void *)tx_queue
+                                                               + stat->offset);
+                        }
+                        break;
                 }
         }
 }
 
-static int efx_ethtool_set_tso(struct net_device *net_dev, u32 enable)
-{
-        struct efx_nic *efx __attribute__ ((unused)) = netdev_priv(net_dev);
-        unsigned long features;
-
-        features = NETIF_F_TSO;
-        if (efx->type->offload_features & NETIF_F_V6_CSUM)
-                features |= NETIF_F_TSO6;
-
-        if (enable)
-                net_dev->features |= features;
-        else
-                net_dev->features &= ~features;
-
-        return 0;
-}
-
-static int efx_ethtool_set_tx_csum(struct net_device *net_dev, u32 enable)
-{
-        struct efx_nic *efx = netdev_priv(net_dev);
-        unsigned long features = efx->type->offload_features & NETIF_F_ALL_CSUM;
-
-        if (enable)
-                net_dev->features |= features;
-        else
-                net_dev->features &= ~features;
-
-        return 0;
-}
-
-static int efx_ethtool_set_rx_csum(struct net_device *net_dev, u32 enable)
-{
-        struct efx_nic *efx = netdev_priv(net_dev);
-
-        /* No way to stop the hardware doing the checks; we just
-         * ignore the result.
-         */
-        efx->rx_checksum_enabled = !!enable;
-
-        return 0;
-}
-
-static u32 efx_ethtool_get_rx_csum(struct net_device *net_dev)
-{
-        struct efx_nic *efx = netdev_priv(net_dev);
-
-        return efx->rx_checksum_enabled;
-}
-
-static int efx_ethtool_set_flags(struct net_device *net_dev, u32 data)
-{
-        struct efx_nic *efx = netdev_priv(net_dev);
-        u32 supported = efx->type->offload_features & ETH_FLAG_RXHASH;
-
-        return ethtool_op_set_flags(net_dev, data, supported);
-}
-
 static void efx_ethtool_self_test(struct net_device *net_dev,
                                   struct ethtool_test *test, u64 *data)
 {
         struct efx_nic *efx = netdev_priv(net_dev);
-        struct efx_self_tests efx_tests;
+        struct efx_self_tests *efx_tests;
         int already_up;
-        int rc;
+        int rc = -ENOMEM;
+
+        efx_tests = kzalloc(sizeof(*efx_tests), GFP_KERNEL);
+        if (!efx_tests)
+                goto fail;
+
 
         ASSERT_RTNL();
         if (efx->state != STATE_RUNNING) {
@@ -569,6 +546,9 @@ static void efx_ethtool_self_test(struct net_device *net_dev,
                 goto fail1;
         }
 
+        netif_info(efx, drv, efx->net_dev, "starting %sline testing\n",
+                   (test->flags & ETH_TEST_FL_OFFLINE) ? "off" : "on");
+
         /* We need rx buffers and interrupts. */
         already_up = (efx->net_dev->flags & IFF_UP);
         if (!already_up) {
@@ -576,25 +556,24 @@ static void efx_ethtool_self_test(struct net_device *net_dev,
                 if (rc) {
                         netif_err(efx, drv, efx->net_dev,
                                   "failed opening device.\n");
-                        goto fail2;
+                        goto fail1;
                 }
         }
 
-        memset(&efx_tests, 0, sizeof(efx_tests));
-
-        rc = efx_selftest(efx, &efx_tests, test->flags);
+        rc = efx_selftest(efx, efx_tests, test->flags);
 
         if (!already_up)
                 dev_close(efx->net_dev);
 
-        netif_dbg(efx, drv, efx->net_dev, "%s %sline self-tests\n",
-                  rc == 0 ? "passed" : "failed",
-                  (test->flags & ETH_TEST_FL_OFFLINE) ? "off" : "on");
+        netif_info(efx, drv, efx->net_dev, "%s %sline self-tests\n",
+                   rc == 0 ? "passed" : "failed",
+                   (test->flags & ETH_TEST_FL_OFFLINE) ? "off" : "on");
 
- fail2:
- fail1:
+fail1:
         /* Fill ethtool results structures */
-        efx_ethtool_fill_self_tests(efx, &efx_tests, NULL, data);
+        efx_ethtool_fill_self_tests(efx, efx_tests, NULL, data);
+        kfree(efx_tests);
+fail:
         if (rc)
                 test->flags |= ETH_TEST_FL_FAILED;
 }
@@ -607,81 +586,19 @@ static int efx_ethtool_nway_reset(struct net_device *net_dev)
         return mdio45_nway_restart(&efx->mdio);
 }
 
-static u32 efx_ethtool_get_link(struct net_device *net_dev)
-{
-        struct efx_nic *efx = netdev_priv(net_dev);
-
-        return efx->link_state.up;
-}
-
-static int efx_ethtool_get_eeprom_len(struct net_device *net_dev)
-{
-        struct efx_nic *efx = netdev_priv(net_dev);
-        struct efx_spi_device *spi = efx->spi_eeprom;
-
-        if (!spi)
-                return 0;
-        return min(spi->size, EFX_EEPROM_BOOTCONFIG_END) -
-                min(spi->size, EFX_EEPROM_BOOTCONFIG_START);
-}
-
-static int efx_ethtool_get_eeprom(struct net_device *net_dev,
-                                  struct ethtool_eeprom *eeprom, u8 *buf)
-{
-        struct efx_nic *efx = netdev_priv(net_dev);
-        struct efx_spi_device *spi = efx->spi_eeprom;
-        size_t len;
-        int rc;
-
-        rc = mutex_lock_interruptible(&efx->spi_lock);
-        if (rc)
-                return rc;
-        rc = falcon_spi_read(efx, spi,
-                             eeprom->offset + EFX_EEPROM_BOOTCONFIG_START,
-                             eeprom->len, &len, buf);
-        mutex_unlock(&efx->spi_lock);
-
-        eeprom->magic = EFX_ETHTOOL_EEPROM_MAGIC;
-        eeprom->len = len;
-        return rc;
-}
-
-static int efx_ethtool_set_eeprom(struct net_device *net_dev,
-                                  struct ethtool_eeprom *eeprom, u8 *buf)
-{
-        struct efx_nic *efx = netdev_priv(net_dev);
-        struct efx_spi_device *spi = efx->spi_eeprom;
-        size_t len;
-        int rc;
-
-        if (eeprom->magic != EFX_ETHTOOL_EEPROM_MAGIC)
-                return -EINVAL;
-
-        rc = mutex_lock_interruptible(&efx->spi_lock);
-        if (rc)
-                return rc;
-        rc = falcon_spi_write(efx, spi,
-                              eeprom->offset + EFX_EEPROM_BOOTCONFIG_START,
-                              eeprom->len, &len, buf);
-        mutex_unlock(&efx->spi_lock);
-
-        eeprom->len = len;
-        return rc;
-}
-
 static int efx_ethtool_get_coalesce(struct net_device *net_dev,
                                     struct ethtool_coalesce *coalesce)
 {
         struct efx_nic *efx = netdev_priv(net_dev);
-        struct efx_tx_queue *tx_queue;
         struct efx_channel *channel;
 
         memset(coalesce, 0, sizeof(*coalesce));
 
         /* Find lowest IRQ moderation across all used TX queues */
         coalesce->tx_coalesce_usecs_irq = ~((u32) 0);
-        efx_for_each_tx_queue(tx_queue, efx) {
-                channel = tx_queue->channel;
+        efx_for_each_channel(channel, efx) {
+                if (!efx_channel_has_tx_queues(channel))
+                        continue;
                 if (channel->irq_moderation < coalesce->tx_coalesce_usecs_irq) {
                         if (channel->channel < efx->n_rx_channels)
                                 coalesce->tx_coalesce_usecs_irq =
@@ -708,7 +625,6 @@ static int efx_ethtool_set_coalesce(struct net_device *net_dev,
 {
         struct efx_nic *efx = netdev_priv(net_dev);
         struct efx_channel *channel;
-        struct efx_tx_queue *tx_queue;
         unsigned tx_usecs, rx_usecs, adaptive;
 
         if (coalesce->use_adaptive_tx_coalesce)
@@ -725,8 +641,9 @@ static int efx_ethtool_set_coalesce(struct net_device *net_dev,
         adaptive = coalesce->use_adaptive_rx_coalesce;
 
         /* If the channel is shared only allow RX parameters to be set */
-        efx_for_each_tx_queue(tx_queue, efx) {
-                if ((tx_queue->channel->channel < efx->n_rx_channels) &&
+        efx_for_each_channel(channel, efx) {
+                if (efx_channel_has_rx_queue(channel) &&
+                    efx_channel_has_tx_queues(channel) &&
                     tx_usecs) {
                         netif_err(efx, drv, efx->net_dev, "Channel is shared. "
                                   "Only RX coalescing may be set\n");
@@ -741,11 +658,47 @@ static int efx_ethtool_set_coalesce(struct net_device *net_dev,
         return 0;
 }
 
+static void efx_ethtool_get_ringparam(struct net_device *net_dev,
+                                      struct ethtool_ringparam *ring)
+{
+        struct efx_nic *efx = netdev_priv(net_dev);
+
+        ring->rx_max_pending = EFX_MAX_DMAQ_SIZE;
+        ring->tx_max_pending = EFX_MAX_DMAQ_SIZE;
+        ring->rx_mini_max_pending = 0;
+        ring->rx_jumbo_max_pending = 0;
+        ring->rx_pending = efx->rxq_entries;
+        ring->tx_pending = efx->txq_entries;
+        ring->rx_mini_pending = 0;
+        ring->rx_jumbo_pending = 0;
+}
+
+static int efx_ethtool_set_ringparam(struct net_device *net_dev,
+                                     struct ethtool_ringparam *ring)
+{
+        struct efx_nic *efx = netdev_priv(net_dev);
+
+        if (ring->rx_mini_pending || ring->rx_jumbo_pending ||
+            ring->rx_pending > EFX_MAX_DMAQ_SIZE ||
+            ring->tx_pending > EFX_MAX_DMAQ_SIZE)
+                return -EINVAL;
+
+        if (ring->rx_pending < EFX_MIN_RING_SIZE ||
+            ring->tx_pending < EFX_MIN_RING_SIZE) {
+                netif_err(efx, drv, efx->net_dev,
+                          "TX and RX queues cannot be smaller than %ld\n",
+                          EFX_MIN_RING_SIZE);
+                return -EINVAL;
+        }
+
+        return efx_realloc_channels(efx, ring->rx_pending, ring->tx_pending);
+}
+
 static int efx_ethtool_set_pauseparam(struct net_device *net_dev,
                                       struct ethtool_pauseparam *pause)
 {
         struct efx_nic *efx = netdev_priv(net_dev);
-        enum efx_fc_type wanted_fc, old_fc;
+        u8 wanted_fc, old_fc;
         u32 old_adv;
         bool reset;
         int rc = 0;
@@ -840,7 +793,7 @@ static int efx_ethtool_set_wol(struct net_device *net_dev,
         return efx->type->set_wol(efx, wol->wolopts);
 }
 
-extern int efx_ethtool_reset(struct net_device *net_dev, u32 *flags)
+static int efx_ethtool_reset(struct net_device *net_dev, u32 *flags)
 {
         struct efx_nic *efx = netdev_priv(net_dev);
         enum reset_type method;
@@ -918,6 +871,95 @@ efx_ethtool_get_rxnfc(struct net_device *net_dev,
         }
 }
 
+static int efx_ethtool_set_rx_ntuple(struct net_device *net_dev,
+                                     struct ethtool_rx_ntuple *ntuple)
+{
+        struct efx_nic *efx = netdev_priv(net_dev);
+        struct ethtool_tcpip4_spec *ip_entry = &ntuple->fs.h_u.tcp_ip4_spec;
+        struct ethtool_tcpip4_spec *ip_mask = &ntuple->fs.m_u.tcp_ip4_spec;
+        struct ethhdr *mac_entry = &ntuple->fs.h_u.ether_spec;
+        struct ethhdr *mac_mask = &ntuple->fs.m_u.ether_spec;
+        struct efx_filter_spec filter;
+        int rc;
+
+        /* Range-check action */
+        if (ntuple->fs.action < ETHTOOL_RXNTUPLE_ACTION_CLEAR ||
+            ntuple->fs.action >= (s32)efx->n_rx_channels)
+                return -EINVAL;
+
+        if (~ntuple->fs.data_mask)
+                return -EINVAL;
+
+        efx_filter_init_rx(&filter, EFX_FILTER_PRI_MANUAL, 0,
+                           (ntuple->fs.action == ETHTOOL_RXNTUPLE_ACTION_DROP) ?
+                           0xfff : ntuple->fs.action);
+
+        switch (ntuple->fs.flow_type) {
+        case TCP_V4_FLOW:
+        case UDP_V4_FLOW: {
+                u8 proto = (ntuple->fs.flow_type == TCP_V4_FLOW ?
+                            IPPROTO_TCP : IPPROTO_UDP);
+
+                /* Must match all of destination, */
+                if (ip_mask->ip4dst | ip_mask->pdst)
+                        return -EINVAL;
+                /* all or none of source, */
+                if ((ip_mask->ip4src | ip_mask->psrc) &&
+                    ((__force u32)~ip_mask->ip4src |
+                     (__force u16)~ip_mask->psrc))
+                        return -EINVAL;
+                /* and nothing else */
+                if ((u8)~ip_mask->tos | (u16)~ntuple->fs.vlan_tag_mask)
+                        return -EINVAL;
+
+                if (!ip_mask->ip4src)
+                        rc = efx_filter_set_ipv4_full(&filter, proto,
+                                                      ip_entry->ip4dst,
+                                                      ip_entry->pdst,
+                                                      ip_entry->ip4src,
+                                                      ip_entry->psrc);
+                else
+                        rc = efx_filter_set_ipv4_local(&filter, proto,
+                                                       ip_entry->ip4dst,
+                                                       ip_entry->pdst);
+                if (rc)
+                        return rc;
+                break;
+        }
+
+        case ETHER_FLOW:
+                /* Must match all of destination, */
+                if (!is_zero_ether_addr(mac_mask->h_dest))
+                        return -EINVAL;
+                /* all or none of VID, */
+                if (ntuple->fs.vlan_tag_mask != 0xf000 &&
+                    ntuple->fs.vlan_tag_mask != 0xffff)
+                        return -EINVAL;
+                /* and nothing else */
+                if (!is_broadcast_ether_addr(mac_mask->h_source) ||
+                    mac_mask->h_proto != htons(0xffff))
+                        return -EINVAL;
+
+                rc = efx_filter_set_eth_local(
+                        &filter,
+                        (ntuple->fs.vlan_tag_mask == 0xf000) ?
+                        ntuple->fs.vlan_tag : EFX_FILTER_VID_UNSPEC,
+                        mac_entry->h_dest);
+                if (rc)
+                        return rc;
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        if (ntuple->fs.action == ETHTOOL_RXNTUPLE_ACTION_CLEAR)
+                return efx_filter_remove_filter(efx, &filter);
+
+        rc = efx_filter_insert_filter(efx, &filter, true);
+        return rc < 0 ? rc : 0;
+}
+
 static int efx_ethtool_get_rxfh_indir(struct net_device *net_dev,
                                       struct ethtool_rxfh_indir *indir)
 {
@@ -965,35 +1007,23 @@ const struct ethtool_ops efx_ethtool_ops = {
         .get_msglevel           = efx_ethtool_get_msglevel,
         .set_msglevel           = efx_ethtool_set_msglevel,
         .nway_reset             = efx_ethtool_nway_reset,
-        .get_link               = efx_ethtool_get_link,
-        .get_eeprom_len         = efx_ethtool_get_eeprom_len,
-        .get_eeprom             = efx_ethtool_get_eeprom,
-        .set_eeprom             = efx_ethtool_set_eeprom,
+        .get_link               = ethtool_op_get_link,
         .get_coalesce           = efx_ethtool_get_coalesce,
         .set_coalesce           = efx_ethtool_set_coalesce,
+        .get_ringparam          = efx_ethtool_get_ringparam,
+        .set_ringparam          = efx_ethtool_set_ringparam,
         .get_pauseparam         = efx_ethtool_get_pauseparam,
         .set_pauseparam         = efx_ethtool_set_pauseparam,
-        .get_rx_csum            = efx_ethtool_get_rx_csum,
-        .set_rx_csum            = efx_ethtool_set_rx_csum,
-        .get_tx_csum            = ethtool_op_get_tx_csum,
-        /* Need to enable/disable IPv6 too */
-        .set_tx_csum            = efx_ethtool_set_tx_csum,
-        .get_sg                 = ethtool_op_get_sg,
-        .set_sg                 = ethtool_op_set_sg,
-        .get_tso                = ethtool_op_get_tso,
-        /* Need to enable/disable TSO-IPv6 too */
-        .set_tso                = efx_ethtool_set_tso,
-        .get_flags              = ethtool_op_get_flags,
-        .set_flags              = efx_ethtool_set_flags,
         .get_sset_count         = efx_ethtool_get_sset_count,
         .self_test              = efx_ethtool_self_test,
         .get_strings            = efx_ethtool_get_strings,
-        .phys_id                = efx_ethtool_phys_id,
+        .set_phys_id            = efx_ethtool_phys_id,
         .get_ethtool_stats      = efx_ethtool_get_stats,
         .get_wol                = efx_ethtool_get_wol,
         .set_wol                = efx_ethtool_set_wol,
         .reset                  = efx_ethtool_reset,
         .get_rxnfc              = efx_ethtool_get_rxnfc,
+        .set_rx_ntuple          = efx_ethtool_set_rx_ntuple,
         .get_rxfh_indir         = efx_ethtool_get_rxfh_indir,
         .set_rxfh_indir         = efx_ethtool_set_rxfh_indir,
 };