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

Pull networking updates from David Miller:
 "Highlights:

   1) Support AES128-CCM ciphers in kTLS, from Vakul Garg.

   2) Add fib_sync_mem to control the amount of dirty memory we allow to
      queue up between synchronize RCU calls, from David Ahern.

   3) Make flow classifier more lockless, from Vlad Buslov.

   4) Add PHY downshift support to aquantia driver, from Heiner
      Kallweit.

   5) Add SKB cache for TCP rx and tx, from Eric Dumazet. This reduces
      contention on SLAB spinlocks in heavy RPC workloads.

   6) Partial GSO offload support in XFRM, from Boris Pismenny.

   7) Add fast link down support to ethtool, from Heiner Kallweit.

   8) Use siphash for IP ID generator, from Eric Dumazet.

   9) Pull nexthops even further out from ipv4/ipv6 routes and FIB
      entries, from David Ahern.

  10) Move skb->xmit_more into a per-cpu variable, from Florian
      Westphal.

  11) Improve eBPF verifier speed and increase maximum program size,
      from Alexei Starovoitov.

  12) Eliminate per-bucket spinlocks in rhashtable, and instead use bit
      spinlocks. From Neil Brown.

  13) Allow tunneling with GUE encap in ipvs, from Jacky Hu.

  14) Improve link partner cap detection in generic PHY code, from
      Heiner Kallweit.

  15) Add layer 2 encap support to bpf_skb_adjust_room(), from Alan
      Maguire.

  16) Remove SKB list implementation assumptions in SCTP, your's truly.

  17) Various cleanups, optimizations, and simplifications in r8169
      driver. From Heiner Kallweit.

  18) Add memory accounting on TX and RX path of SCTP, from Xin Long.

  19) Switch PHY drivers over to use dynamic featue detection, from
      Heiner Kallweit.

  20) Support flow steering without masking in dpaa2-eth, from Ioana
      Ciocoi.

  21) Implement ndo_get_devlink_port in netdevsim driver, from Jiri
      Pirko.

  22) Increase the strict parsing of current and future netlink
      attributes, also export such policies to userspace. From Johannes
      Berg.

  23) Allow DSA tag drivers to be modular, from Andrew Lunn.

  24) Remove legacy DSA probing support, also from Andrew Lunn.

  25) Allow ll_temac driver to be used on non-x86 platforms, from Esben
      Haabendal.

  26) Add a generic tracepoint for TX queue timeouts to ease debugging,
      from Cong Wang.

  27) More indirect call optimizations, from Paolo Abeni"

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next: (1763 commits)
  cxgb4: Fix error path in cxgb4_init_module
  net: phy: improve pause mode reporting in phy_print_status
  dt-bindings: net: Fix a typo in the phy-mode list for ethernet bindings
  net: macb: Change interrupt and napi enable order in open
  net: ll_temac: Improve error message on error IRQ
  net/sched: remove block pointer from common offload structure
  net: ethernet: support of_get_mac_address new ERR_PTR error
  net: usb: smsc: fix warning reported by kbuild test robot
  staging: octeon-ethernet: Fix of_get_mac_address ERR_PTR check
  net: dsa: support of_get_mac_address new ERR_PTR error
  net: dsa: sja1105: Fix status initialization in sja1105_get_ethtool_stats
  vrf: sit mtu should not be updated when vrf netdev is the link
  net: dsa: Fix error cleanup path in dsa_init_module
  l2tp: Fix possible NULL pointer dereference
  taprio: add null check on sched_nest to avoid potential null pointer dereference
  net: mvpp2: cls: fix less than zero check on a u32 variable
  net_sched: sch_fq: handle non connected flows
  net_sched: sch_fq: do not assume EDT packets are ordered
  net: hns3: use devm_kcalloc when allocating desc_cb
  net: hns3: some cleanup for struct hns3_enet_ring
  ...

1 files changed, 448 insertions, 3 deletions

diff --git a/drivers/net/ethernet/intel/igc/igc_main.c b/drivers/net/ethernet/intel/igc/igc_main.c
index f8d692f6aa4f..34fa0e60a780 100644
--- a/drivers/net/ethernet/intel/igc/igc_main.c
+++ b/drivers/net/ethernet/intel/igc/igc_main.c
@@ -620,6 +620,55 @@ static void igc_configure_tx(struct igc_adapter *adapter)
  */
 static void igc_setup_mrqc(struct igc_adapter *adapter)
 {
+        struct igc_hw *hw = &adapter->hw;
+        u32 j, num_rx_queues;
+        u32 mrqc, rxcsum;
+        u32 rss_key[10];
+
+        netdev_rss_key_fill(rss_key, sizeof(rss_key));
+        for (j = 0; j < 10; j++)
+                wr32(IGC_RSSRK(j), rss_key[j]);
+
+        num_rx_queues = adapter->rss_queues;
+
+        if (adapter->rss_indir_tbl_init != num_rx_queues) {
+                for (j = 0; j < IGC_RETA_SIZE; j++)
+                        adapter->rss_indir_tbl[j] =
+                        (j * num_rx_queues) / IGC_RETA_SIZE;
+                adapter->rss_indir_tbl_init = num_rx_queues;
+        }
+        igc_write_rss_indir_tbl(adapter);
+
+        /* Disable raw packet checksumming so that RSS hash is placed in
+         * descriptor on writeback.  No need to enable TCP/UDP/IP checksum
+         * offloads as they are enabled by default
+         */
+        rxcsum = rd32(IGC_RXCSUM);
+        rxcsum |= IGC_RXCSUM_PCSD;
+
+        /* Enable Receive Checksum Offload for SCTP */
+        rxcsum |= IGC_RXCSUM_CRCOFL;
+
+        /* Don't need to set TUOFL or IPOFL, they default to 1 */
+        wr32(IGC_RXCSUM, rxcsum);
+
+        /* Generate RSS hash based on packet types, TCP/UDP
+         * port numbers and/or IPv4/v6 src and dst addresses
+         */
+        mrqc = IGC_MRQC_RSS_FIELD_IPV4 |
+               IGC_MRQC_RSS_FIELD_IPV4_TCP |
+               IGC_MRQC_RSS_FIELD_IPV6 |
+               IGC_MRQC_RSS_FIELD_IPV6_TCP |
+               IGC_MRQC_RSS_FIELD_IPV6_TCP_EX;
+
+        if (adapter->flags & IGC_FLAG_RSS_FIELD_IPV4_UDP)
+                mrqc |= IGC_MRQC_RSS_FIELD_IPV4_UDP;
+        if (adapter->flags & IGC_FLAG_RSS_FIELD_IPV6_UDP)
+                mrqc |= IGC_MRQC_RSS_FIELD_IPV6_UDP;
+
+        mrqc |= IGC_MRQC_ENABLE_RSS_MQ;
+
+        wr32(IGC_MRQC, mrqc);
 }
 
 /**
@@ -890,7 +939,7 @@ static int igc_tx_map(struct igc_ring *tx_ring,
         /* Make sure there is space in the ring for the next send. */
         igc_maybe_stop_tx(tx_ring, DESC_NEEDED);
 
-        if (netif_xmit_stopped(txring_txq(tx_ring)) || !skb->xmit_more) {
+        if (netif_xmit_stopped(txring_txq(tx_ring)) || !netdev_xmit_more()) {
                 writel(i, tx_ring->tail);
         }
 
@@ -1145,7 +1194,7 @@ static struct sk_buff *igc_construct_skb(struct igc_ring *rx_ring,
         /* Determine available headroom for copy */
         headlen = size;
         if (headlen > IGC_RX_HDR_LEN)
-                headlen = eth_get_headlen(va, IGC_RX_HDR_LEN);
+                headlen = eth_get_headlen(skb->dev, va, IGC_RX_HDR_LEN);
 
         /* align pull length to size of long to optimize memcpy performance */
         memcpy(__skb_put(skb, headlen), va, ALIGN(headlen, sizeof(long)));
@@ -1733,12 +1782,200 @@ void igc_up(struct igc_adapter *adapter)
  * igc_update_stats - Update the board statistics counters
  * @adapter: board private structure
  */
-static void igc_update_stats(struct igc_adapter *adapter)
+void igc_update_stats(struct igc_adapter *adapter)
 {
+        struct rtnl_link_stats64 *net_stats = &adapter->stats64;
+        struct pci_dev *pdev = adapter->pdev;
+        struct igc_hw *hw = &adapter->hw;
+        u64 _bytes, _packets;
+        u64 bytes, packets;
+        unsigned int start;
+        u32 mpc;
+        int i;
+
+        /* Prevent stats update while adapter is being reset, or if the pci
+         * connection is down.
+         */
+        if (adapter->link_speed == 0)
+                return;
+        if (pci_channel_offline(pdev))
+                return;
+
+        packets = 0;
+        bytes = 0;
+
+        rcu_read_lock();
+        for (i = 0; i < adapter->num_rx_queues; i++) {
+                struct igc_ring *ring = adapter->rx_ring[i];
+                u32 rqdpc = rd32(IGC_RQDPC(i));
+
+                if (hw->mac.type >= igc_i225)
+                        wr32(IGC_RQDPC(i), 0);
+
+                if (rqdpc) {
+                        ring->rx_stats.drops += rqdpc;
+                        net_stats->rx_fifo_errors += rqdpc;
+                }
+
+                do {
+                        start = u64_stats_fetch_begin_irq(&ring->rx_syncp);
+                        _bytes = ring->rx_stats.bytes;
+                        _packets = ring->rx_stats.packets;
+                } while (u64_stats_fetch_retry_irq(&ring->rx_syncp, start));
+                bytes += _bytes;
+                packets += _packets;
+        }
+
+        net_stats->rx_bytes = bytes;
+        net_stats->rx_packets = packets;
+
+        packets = 0;
+        bytes = 0;
+        for (i = 0; i < adapter->num_tx_queues; i++) {
+                struct igc_ring *ring = adapter->tx_ring[i];
+
+                do {
+                        start = u64_stats_fetch_begin_irq(&ring->tx_syncp);
+                        _bytes = ring->tx_stats.bytes;
+                        _packets = ring->tx_stats.packets;
+                } while (u64_stats_fetch_retry_irq(&ring->tx_syncp, start));
+                bytes += _bytes;
+                packets += _packets;
+        }
+        net_stats->tx_bytes = bytes;
+        net_stats->tx_packets = packets;
+        rcu_read_unlock();
+
+        /* read stats registers */
+        adapter->stats.crcerrs += rd32(IGC_CRCERRS);
+        adapter->stats.gprc += rd32(IGC_GPRC);
+        adapter->stats.gorc += rd32(IGC_GORCL);
+        rd32(IGC_GORCH); /* clear GORCL */
+        adapter->stats.bprc += rd32(IGC_BPRC);
+        adapter->stats.mprc += rd32(IGC_MPRC);
+        adapter->stats.roc += rd32(IGC_ROC);
+
+        adapter->stats.prc64 += rd32(IGC_PRC64);
+        adapter->stats.prc127 += rd32(IGC_PRC127);
+        adapter->stats.prc255 += rd32(IGC_PRC255);
+        adapter->stats.prc511 += rd32(IGC_PRC511);
+        adapter->stats.prc1023 += rd32(IGC_PRC1023);
+        adapter->stats.prc1522 += rd32(IGC_PRC1522);
+        adapter->stats.symerrs += rd32(IGC_SYMERRS);
+        adapter->stats.sec += rd32(IGC_SEC);
+
+        mpc = rd32(IGC_MPC);
+        adapter->stats.mpc += mpc;
+        net_stats->rx_fifo_errors += mpc;
+        adapter->stats.scc += rd32(IGC_SCC);
+        adapter->stats.ecol += rd32(IGC_ECOL);
+        adapter->stats.mcc += rd32(IGC_MCC);
+        adapter->stats.latecol += rd32(IGC_LATECOL);
+        adapter->stats.dc += rd32(IGC_DC);
+        adapter->stats.rlec += rd32(IGC_RLEC);
+        adapter->stats.xonrxc += rd32(IGC_XONRXC);
+        adapter->stats.xontxc += rd32(IGC_XONTXC);
+        adapter->stats.xoffrxc += rd32(IGC_XOFFRXC);
+        adapter->stats.xofftxc += rd32(IGC_XOFFTXC);
+        adapter->stats.fcruc += rd32(IGC_FCRUC);
+        adapter->stats.gptc += rd32(IGC_GPTC);
+        adapter->stats.gotc += rd32(IGC_GOTCL);
+        rd32(IGC_GOTCH); /* clear GOTCL */
+        adapter->stats.rnbc += rd32(IGC_RNBC);
+        adapter->stats.ruc += rd32(IGC_RUC);
+        adapter->stats.rfc += rd32(IGC_RFC);
+        adapter->stats.rjc += rd32(IGC_RJC);
+        adapter->stats.tor += rd32(IGC_TORH);
+        adapter->stats.tot += rd32(IGC_TOTH);
+        adapter->stats.tpr += rd32(IGC_TPR);
+
+        adapter->stats.ptc64 += rd32(IGC_PTC64);
+        adapter->stats.ptc127 += rd32(IGC_PTC127);
+        adapter->stats.ptc255 += rd32(IGC_PTC255);
+        adapter->stats.ptc511 += rd32(IGC_PTC511);
+        adapter->stats.ptc1023 += rd32(IGC_PTC1023);
+        adapter->stats.ptc1522 += rd32(IGC_PTC1522);
+
+        adapter->stats.mptc += rd32(IGC_MPTC);
+        adapter->stats.bptc += rd32(IGC_BPTC);
+
+        adapter->stats.tpt += rd32(IGC_TPT);
+        adapter->stats.colc += rd32(IGC_COLC);
+
+        adapter->stats.algnerrc += rd32(IGC_ALGNERRC);
+
+        adapter->stats.tsctc += rd32(IGC_TSCTC);
+        adapter->stats.tsctfc += rd32(IGC_TSCTFC);
+
+        adapter->stats.iac += rd32(IGC_IAC);
+        adapter->stats.icrxoc += rd32(IGC_ICRXOC);
+        adapter->stats.icrxptc += rd32(IGC_ICRXPTC);
+        adapter->stats.icrxatc += rd32(IGC_ICRXATC);
+        adapter->stats.ictxptc += rd32(IGC_ICTXPTC);
+        adapter->stats.ictxatc += rd32(IGC_ICTXATC);
+        adapter->stats.ictxqec += rd32(IGC_ICTXQEC);
+        adapter->stats.ictxqmtc += rd32(IGC_ICTXQMTC);
+        adapter->stats.icrxdmtc += rd32(IGC_ICRXDMTC);
+
+        /* Fill out the OS statistics structure */
+        net_stats->multicast = adapter->stats.mprc;
+        net_stats->collisions = adapter->stats.colc;
+
+        /* Rx Errors */
+
+        /* RLEC on some newer hardware can be incorrect so build
+         * our own version based on RUC and ROC
+         */
+        net_stats->rx_errors = adapter->stats.rxerrc +
+                adapter->stats.crcerrs + adapter->stats.algnerrc +
+                adapter->stats.ruc + adapter->stats.roc +
+                adapter->stats.cexterr;
+        net_stats->rx_length_errors = adapter->stats.ruc +
+                                      adapter->stats.roc;
+        net_stats->rx_crc_errors = adapter->stats.crcerrs;
+        net_stats->rx_frame_errors = adapter->stats.algnerrc;
+        net_stats->rx_missed_errors = adapter->stats.mpc;
+
+        /* Tx Errors */
+        net_stats->tx_errors = adapter->stats.ecol +
+                               adapter->stats.latecol;
+        net_stats->tx_aborted_errors = adapter->stats.ecol;
+        net_stats->tx_window_errors = adapter->stats.latecol;
+        net_stats->tx_carrier_errors = adapter->stats.tncrs;
+
+        /* Tx Dropped needs to be maintained elsewhere */
+
+        /* Management Stats */
+        adapter->stats.mgptc += rd32(IGC_MGTPTC);
+        adapter->stats.mgprc += rd32(IGC_MGTPRC);
+        adapter->stats.mgpdc += rd32(IGC_MGTPDC);
 }
 
 static void igc_nfc_filter_exit(struct igc_adapter *adapter)
 {
+        struct igc_nfc_filter *rule;
+
+        spin_lock(&adapter->nfc_lock);
+
+        hlist_for_each_entry(rule, &adapter->nfc_filter_list, nfc_node)
+                igc_erase_filter(adapter, rule);
+
+        hlist_for_each_entry(rule, &adapter->cls_flower_list, nfc_node)
+                igc_erase_filter(adapter, rule);
+
+        spin_unlock(&adapter->nfc_lock);
+}
+
+static void igc_nfc_filter_restore(struct igc_adapter *adapter)
+{
+        struct igc_nfc_filter *rule;
+
+        spin_lock(&adapter->nfc_lock);
+
+        hlist_for_each_entry(rule, &adapter->nfc_filter_list, nfc_node)
+                igc_add_filter(adapter, rule);
+
+        spin_unlock(&adapter->nfc_lock);
 }
 
 /**
@@ -1885,6 +2122,86 @@ static struct net_device_stats *igc_get_stats(struct net_device *netdev)
         return &netdev->stats;
 }
 
+static netdev_features_t igc_fix_features(struct net_device *netdev,
+                                          netdev_features_t features)
+{
+        /* Since there is no support for separate Rx/Tx vlan accel
+         * enable/disable make sure Tx flag is always in same state as Rx.
+         */
+        if (features & NETIF_F_HW_VLAN_CTAG_RX)
+                features |= NETIF_F_HW_VLAN_CTAG_TX;
+        else
+                features &= ~NETIF_F_HW_VLAN_CTAG_TX;
+
+        return features;
+}
+
+static int igc_set_features(struct net_device *netdev,
+                            netdev_features_t features)
+{
+        netdev_features_t changed = netdev->features ^ features;
+        struct igc_adapter *adapter = netdev_priv(netdev);
+
+        /* Add VLAN support */
+        if (!(changed & (NETIF_F_RXALL | NETIF_F_NTUPLE)))
+                return 0;
+
+        if (!(features & NETIF_F_NTUPLE)) {
+                struct hlist_node *node2;
+                struct igc_nfc_filter *rule;
+
+                spin_lock(&adapter->nfc_lock);
+                hlist_for_each_entry_safe(rule, node2,
+                                          &adapter->nfc_filter_list, nfc_node) {
+                        igc_erase_filter(adapter, rule);
+                        hlist_del(&rule->nfc_node);
+                        kfree(rule);
+                }
+                spin_unlock(&adapter->nfc_lock);
+                adapter->nfc_filter_count = 0;
+        }
+
+        netdev->features = features;
+
+        if (netif_running(netdev))
+                igc_reinit_locked(adapter);
+        else
+                igc_reset(adapter);
+
+        return 1;
+}
+
+static netdev_features_t
+igc_features_check(struct sk_buff *skb, struct net_device *dev,
+                   netdev_features_t features)
+{
+        unsigned int network_hdr_len, mac_hdr_len;
+
+        /* Make certain the headers can be described by a context descriptor */
+        mac_hdr_len = skb_network_header(skb) - skb->data;
+        if (unlikely(mac_hdr_len > IGC_MAX_MAC_HDR_LEN))
+                return features & ~(NETIF_F_HW_CSUM |
+                                    NETIF_F_SCTP_CRC |
+                                    NETIF_F_HW_VLAN_CTAG_TX |
+                                    NETIF_F_TSO |
+                                    NETIF_F_TSO6);
+
+        network_hdr_len = skb_checksum_start(skb) - skb_network_header(skb);
+        if (unlikely(network_hdr_len >  IGC_MAX_NETWORK_HDR_LEN))
+                return features & ~(NETIF_F_HW_CSUM |
+                                    NETIF_F_SCTP_CRC |
+                                    NETIF_F_TSO |
+                                    NETIF_F_TSO6);
+
+        /* We can only support IPv4 TSO in tunnels if we can mangle the
+         * inner IP ID field, so strip TSO if MANGLEID is not supported.
+         */
+        if (skb->encapsulation && !(features & NETIF_F_TSO_MANGLEID))
+                features &= ~NETIF_F_TSO;
+
+        return features;
+}
+
 /**
  * igc_configure - configure the hardware for RX and TX
  * @adapter: private board structure
@@ -1901,6 +2218,7 @@ static void igc_configure(struct igc_adapter *adapter)
         igc_setup_mrqc(adapter);
         igc_setup_rctl(adapter);
 
+        igc_nfc_filter_restore(adapter);
         igc_configure_tx(adapter);
         igc_configure_rx(adapter);
 
@@ -1962,6 +2280,127 @@ static void igc_set_default_mac_filter(struct igc_adapter *adapter)
         igc_rar_set_index(adapter, 0);
 }
 
+/* If the filter to be added and an already existing filter express
+ * the same address and address type, it should be possible to only
+ * override the other configurations, for example the queue to steer
+ * traffic.
+ */
+static bool igc_mac_entry_can_be_used(const struct igc_mac_addr *entry,
+                                      const u8 *addr, const u8 flags)
+{
+        if (!(entry->state & IGC_MAC_STATE_IN_USE))
+                return true;
+
+        if ((entry->state & IGC_MAC_STATE_SRC_ADDR) !=
+            (flags & IGC_MAC_STATE_SRC_ADDR))
+                return false;
+
+        if (!ether_addr_equal(addr, entry->addr))
+                return false;
+
+        return true;
+}
+
+/* Add a MAC filter for 'addr' directing matching traffic to 'queue',
+ * 'flags' is used to indicate what kind of match is made, match is by
+ * default for the destination address, if matching by source address
+ * is desired the flag IGC_MAC_STATE_SRC_ADDR can be used.
+ */
+static int igc_add_mac_filter_flags(struct igc_adapter *adapter,
+                                    const u8 *addr, const u8 queue,
+                                    const u8 flags)
+{
+        struct igc_hw *hw = &adapter->hw;
+        int rar_entries = hw->mac.rar_entry_count;
+        int i;
+
+        if (is_zero_ether_addr(addr))
+                return -EINVAL;
+
+        /* Search for the first empty entry in the MAC table.
+         * Do not touch entries at the end of the table reserved for the VF MAC
+         * addresses.
+         */
+        for (i = 0; i < rar_entries; i++) {
+                if (!igc_mac_entry_can_be_used(&adapter->mac_table[i],
+                                               addr, flags))
+                        continue;
+
+                ether_addr_copy(adapter->mac_table[i].addr, addr);
+                adapter->mac_table[i].queue = queue;
+                adapter->mac_table[i].state |= IGC_MAC_STATE_IN_USE | flags;
+
+                igc_rar_set_index(adapter, i);
+                return i;
+        }
+
+        return -ENOSPC;
+}
+
+int igc_add_mac_steering_filter(struct igc_adapter *adapter,
+                                const u8 *addr, u8 queue, u8 flags)
+{
+        return igc_add_mac_filter_flags(adapter, addr, queue,
+                                        IGC_MAC_STATE_QUEUE_STEERING | flags);
+}
+
+/* Remove a MAC filter for 'addr' directing matching traffic to
+ * 'queue', 'flags' is used to indicate what kind of match need to be
+ * removed, match is by default for the destination address, if
+ * matching by source address is to be removed the flag
+ * IGC_MAC_STATE_SRC_ADDR can be used.
+ */
+static int igc_del_mac_filter_flags(struct igc_adapter *adapter,
+                                    const u8 *addr, const u8 queue,
+                                    const u8 flags)
+{
+        struct igc_hw *hw = &adapter->hw;
+        int rar_entries = hw->mac.rar_entry_count;
+        int i;
+
+        if (is_zero_ether_addr(addr))
+                return -EINVAL;
+
+        /* Search for matching entry in the MAC table based on given address
+         * and queue. Do not touch entries at the end of the table reserved
+         * for the VF MAC addresses.
+         */
+        for (i = 0; i < rar_entries; i++) {
+                if (!(adapter->mac_table[i].state & IGC_MAC_STATE_IN_USE))
+                        continue;
+                if ((adapter->mac_table[i].state & flags) != flags)
+                        continue;
+                if (adapter->mac_table[i].queue != queue)
+                        continue;
+                if (!ether_addr_equal(adapter->mac_table[i].addr, addr))
+                        continue;
+
+                /* When a filter for the default address is "deleted",
+                 * we return it to its initial configuration
+                 */
+                if (adapter->mac_table[i].state & IGC_MAC_STATE_DEFAULT) {
+                        adapter->mac_table[i].state =
+                                IGC_MAC_STATE_DEFAULT | IGC_MAC_STATE_IN_USE;
+                } else {
+                        adapter->mac_table[i].state = 0;
+                        adapter->mac_table[i].queue = 0;
+                        memset(adapter->mac_table[i].addr, 0, ETH_ALEN);
+                }
+
+                igc_rar_set_index(adapter, i);
+                return 0;
+        }
+
+        return -ENOENT;
+}
+
+int igc_del_mac_steering_filter(struct igc_adapter *adapter,
+                                const u8 *addr, u8 queue, u8 flags)
+{
+        return igc_del_mac_filter_flags(adapter, addr, queue,
+                                        IGC_MAC_STATE_QUEUE_STEERING | flags);
+}
+
 /**
  * igc_set_rx_mode - Secondary Unicast, Multicast and Promiscuous mode set
  * @netdev: network interface device structure
@@ -3429,6 +3868,9 @@ static const struct net_device_ops igc_netdev_ops = {
         .ndo_set_mac_address    = igc_set_mac,
         .ndo_change_mtu         = igc_change_mtu,
         .ndo_get_stats          = igc_get_stats,
+        .ndo_fix_features       = igc_fix_features,
+        .ndo_set_features       = igc_set_features,
+        .ndo_features_check     = igc_features_check,
 };
 
 /* PCIe configuration access */
@@ -3658,6 +4100,9 @@ static int igc_probe(struct pci_dev *pdev,
         if (err)
                 goto err_sw_init;
 
+        /* copy netdev features into list of user selectable features */
+        netdev->hw_features |= NETIF_F_NTUPLE;
+
         /* MTU range: 68 - 9216 */
         netdev->min_mtu = ETH_MIN_MTU;
         netdev->max_mtu = MAX_STD_JUMBO_FRAME_SIZE;