git.droids-corp.org / dpdk.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
net/ngbe: support MAC filters
[dpdk.git] / drivers / net / sfc / sfc_rx.c
diff --git a/drivers/net/sfc/sfc_rx.c b/drivers/net/sfc/sfc_rx.c
index f6a8ac6..e2be84b 100644 (file)
--- a/drivers/net/sfc/sfc_rx.c
+++ b/drivers/net/sfc/sfc_rx.c
@@ -13,6 +13,7 @@
 
 #include "sfc.h"
 #include "sfc_debug.h"
+#include "sfc_flow_tunnel.h"
 #include "sfc_log.h"
 #include "sfc_ev.h"
 #include "sfc_rx.h"
@@ -138,6 +139,7 @@ sfc_efx_rx_qrefill(struct sfc_efx_rxq *rxq)
        SFC_ASSERT(added != rxq->added);
        rxq->added = added;
        efx_rx_qpush(rxq->common, added, &rxq->pushed);
+       rxq->dp.dpq.rx_dbells++;
 }
 
 static uint64_t
@@ -147,15 +149,15 @@ sfc_efx_rx_desc_flags_to_offload_flags(const unsigned int desc_flags)
 
        switch (desc_flags & (EFX_PKT_IPV4 | EFX_CKSUM_IPV4)) {
        case (EFX_PKT_IPV4 | EFX_CKSUM_IPV4):
-               mbuf_flags |= PKT_RX_IP_CKSUM_GOOD;
+               mbuf_flags |= RTE_MBUF_F_RX_IP_CKSUM_GOOD;
                break;
        case EFX_PKT_IPV4:
-               mbuf_flags |= PKT_RX_IP_CKSUM_BAD;
+               mbuf_flags |= RTE_MBUF_F_RX_IP_CKSUM_BAD;
                break;
        default:
-               RTE_BUILD_BUG_ON(PKT_RX_IP_CKSUM_UNKNOWN != 0);
-               SFC_ASSERT((mbuf_flags & PKT_RX_IP_CKSUM_MASK) ==
-                          PKT_RX_IP_CKSUM_UNKNOWN);
+               RTE_BUILD_BUG_ON(RTE_MBUF_F_RX_IP_CKSUM_UNKNOWN != 0);
+               SFC_ASSERT((mbuf_flags & RTE_MBUF_F_RX_IP_CKSUM_MASK) ==
+                          RTE_MBUF_F_RX_IP_CKSUM_UNKNOWN);
                break;
        }
 
@@ -163,16 +165,16 @@ sfc_efx_rx_desc_flags_to_offload_flags(const unsigned int desc_flags)
                 (EFX_PKT_TCP | EFX_PKT_UDP | EFX_CKSUM_TCPUDP))) {
        case (EFX_PKT_TCP | EFX_CKSUM_TCPUDP):
        case (EFX_PKT_UDP | EFX_CKSUM_TCPUDP):
-               mbuf_flags |= PKT_RX_L4_CKSUM_GOOD;
+               mbuf_flags |= RTE_MBUF_F_RX_L4_CKSUM_GOOD;
                break;
        case EFX_PKT_TCP:
        case EFX_PKT_UDP:
-               mbuf_flags |= PKT_RX_L4_CKSUM_BAD;
+               mbuf_flags |= RTE_MBUF_F_RX_L4_CKSUM_BAD;
                break;
        default:
-               RTE_BUILD_BUG_ON(PKT_RX_L4_CKSUM_UNKNOWN != 0);
-               SFC_ASSERT((mbuf_flags & PKT_RX_L4_CKSUM_MASK) ==
-                          PKT_RX_L4_CKSUM_UNKNOWN);
+               RTE_BUILD_BUG_ON(RTE_MBUF_F_RX_L4_CKSUM_UNKNOWN != 0);
+               SFC_ASSERT((mbuf_flags & RTE_MBUF_F_RX_L4_CKSUM_MASK) ==
+                          RTE_MBUF_F_RX_L4_CKSUM_UNKNOWN);
                break;
        }
 
@@ -223,7 +225,7 @@ sfc_efx_rx_set_rss_hash(struct sfc_efx_rxq *rxq, unsigned int flags,
                                                      EFX_RX_HASHALG_TOEPLITZ,
                                                      mbuf_data);
 
-               m->ol_flags |= PKT_RX_RSS_HASH;
+               m->ol_flags |= RTE_MBUF_F_RX_RSS_HASH;
        }
 }
 
@@ -646,9 +648,9 @@ struct sfc_dp_rx sfc_efx_rx = {
                .hw_fw_caps     = SFC_DP_HW_FW_CAP_RX_EFX,
        },
        .features               = SFC_DP_RX_FEAT_INTR,
-       .dev_offload_capa       = DEV_RX_OFFLOAD_CHECKSUM |
-                                 DEV_RX_OFFLOAD_RSS_HASH,
-       .queue_offload_capa     = DEV_RX_OFFLOAD_SCATTER,
+       .dev_offload_capa       = RTE_ETH_RX_OFFLOAD_CHECKSUM |
+                                 RTE_ETH_RX_OFFLOAD_RSS_HASH,
+       .queue_offload_capa     = RTE_ETH_RX_OFFLOAD_SCATTER,
        .qsize_up_rings         = sfc_efx_rx_qsize_up_rings,
        .qcreate                = sfc_efx_rx_qcreate,
        .qdestroy               = sfc_efx_rx_qdestroy,
@@ -929,7 +931,7 @@ sfc_rx_get_offload_mask(struct sfc_adapter *sa)
        uint64_t no_caps = 0;
 
        if (encp->enc_tunnel_encapsulations_supported == 0)
-               no_caps |= DEV_RX_OFFLOAD_OUTER_IPV4_CKSUM;
+               no_caps |= RTE_ETH_RX_OFFLOAD_OUTER_IPV4_CKSUM;
 
        return ~no_caps;
 }
@@ -939,8 +941,6 @@ sfc_rx_get_dev_offload_caps(struct sfc_adapter *sa)
 {
        uint64_t caps = sa->priv.dp_rx->dev_offload_capa;
 
-       caps |= DEV_RX_OFFLOAD_JUMBO_FRAME;
-
        return caps & sfc_rx_get_offload_mask(sa);
 }
 
@@ -1140,7 +1140,7 @@ sfc_rx_qinit(struct sfc_adapter *sa, sfc_sw_index_t sw_index,
 
        if (!sfc_rx_check_scatter(sa->port.pdu, buf_size,
                                  encp->enc_rx_prefix_size,
-                                 (offloads & DEV_RX_OFFLOAD_SCATTER),
+                                 (offloads & RTE_ETH_RX_OFFLOAD_SCATTER),
                                  encp->enc_rx_scatter_max,
                                  &error)) {
                sfc_err(sa, "RxQ %d (internal %u) MTU check failed: %s",
@@ -1166,17 +1166,24 @@ sfc_rx_qinit(struct sfc_adapter *sa, sfc_sw_index_t sw_index,
                rxq_info->type = EFX_RXQ_TYPE_DEFAULT;
 
        rxq_info->type_flags |=
-               (offloads & DEV_RX_OFFLOAD_SCATTER) ?
+               (offloads & RTE_ETH_RX_OFFLOAD_SCATTER) ?
                EFX_RXQ_FLAG_SCATTER : EFX_RXQ_FLAG_NONE;
 
        if ((encp->enc_tunnel_encapsulations_supported != 0) &&
            (sfc_dp_rx_offload_capa(sa->priv.dp_rx) &
-            DEV_RX_OFFLOAD_OUTER_IPV4_CKSUM) != 0)
+            RTE_ETH_RX_OFFLOAD_OUTER_IPV4_CKSUM) != 0)
                rxq_info->type_flags |= EFX_RXQ_FLAG_INNER_CLASSES;
 
-       if (offloads & DEV_RX_OFFLOAD_RSS_HASH)
+       if (offloads & RTE_ETH_RX_OFFLOAD_RSS_HASH)
                rxq_info->type_flags |= EFX_RXQ_FLAG_RSS_HASH;
 
+       if ((sa->negotiated_rx_metadata & RTE_ETH_RX_METADATA_USER_FLAG) != 0)
+               rxq_info->type_flags |= EFX_RXQ_FLAG_USER_FLAG;
+
+       if ((sa->negotiated_rx_metadata & RTE_ETH_RX_METADATA_USER_MARK) != 0 ||
+           sfc_flow_tunnel_is_active(sa))
+               rxq_info->type_flags |= EFX_RXQ_FLAG_USER_MARK;
+
        rc = sfc_ev_qinit(sa, SFC_EVQ_TYPE_RX, sw_index,
                          evq_entries, socket_id, &evq);
        if (rc != 0)
@@ -1204,7 +1211,7 @@ sfc_rx_qinit(struct sfc_adapter *sa, sfc_sw_index_t sw_index,
        rxq_info->refill_mb_pool = mb_pool;
 
        if (rss->hash_support == EFX_RX_HASH_AVAILABLE && rss->channels > 0 &&
-           (offloads & DEV_RX_OFFLOAD_RSS_HASH))
+           (offloads & RTE_ETH_RX_OFFLOAD_RSS_HASH))
                rxq_info->rxq_flags = SFC_RXQ_FLAG_RSS_HASH;
        else
                rxq_info->rxq_flags = 0;
@@ -1224,6 +1231,12 @@ sfc_rx_qinit(struct sfc_adapter *sa, sfc_sw_index_t sw_index,
        info.buf_size = buf_size;
        info.batch_max = encp->enc_rx_batch_max;
        info.prefix_size = encp->enc_rx_prefix_size;
+
+       if (sfc_flow_tunnel_is_active(sa))
+               info.user_mark_mask = SFC_FT_USER_MARK_MASK;
+       else
+               info.user_mark_mask = UINT32_MAX;
+
        info.flags = rxq_info->rxq_flags;
        info.rxq_entries = rxq_info->entries;
        info.rxq_hw_ring = rxq->mem.esm_base;
@@ -1300,19 +1313,19 @@ sfc_rx_qfini(struct sfc_adapter *sa, sfc_sw_index_t sw_index)
  * Mapping between RTE RSS hash functions and their EFX counterparts.
  */
 static const struct sfc_rss_hf_rte_to_efx sfc_rss_hf_map[] = {
-       { ETH_RSS_NONFRAG_IPV4_TCP,
+       { RTE_ETH_RSS_NONFRAG_IPV4_TCP,
          EFX_RX_HASH(IPV4_TCP, 4TUPLE) },
-       { ETH_RSS_NONFRAG_IPV4_UDP,
+       { RTE_ETH_RSS_NONFRAG_IPV4_UDP,
          EFX_RX_HASH(IPV4_UDP, 4TUPLE) },
-       { ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_IPV6_TCP_EX,
+       { RTE_ETH_RSS_NONFRAG_IPV6_TCP | RTE_ETH_RSS_IPV6_TCP_EX,
          EFX_RX_HASH(IPV6_TCP, 4TUPLE) },
-       { ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_IPV6_UDP_EX,
+       { RTE_ETH_RSS_NONFRAG_IPV6_UDP | RTE_ETH_RSS_IPV6_UDP_EX,
          EFX_RX_HASH(IPV6_UDP, 4TUPLE) },
-       { ETH_RSS_IPV4 | ETH_RSS_FRAG_IPV4 | ETH_RSS_NONFRAG_IPV4_OTHER,
+       { RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_FRAG_IPV4 | RTE_ETH_RSS_NONFRAG_IPV4_OTHER,
          EFX_RX_HASH(IPV4_TCP, 2TUPLE) | EFX_RX_HASH(IPV4_UDP, 2TUPLE) |
          EFX_RX_HASH(IPV4, 2TUPLE) },
-       { ETH_RSS_IPV6 | ETH_RSS_FRAG_IPV6 | ETH_RSS_NONFRAG_IPV6_OTHER |
-         ETH_RSS_IPV6_EX,
+       { RTE_ETH_RSS_IPV6 | RTE_ETH_RSS_FRAG_IPV6 | RTE_ETH_RSS_NONFRAG_IPV6_OTHER |
+         RTE_ETH_RSS_IPV6_EX,
          EFX_RX_HASH(IPV6_TCP, 2TUPLE) | EFX_RX_HASH(IPV6_UDP, 2TUPLE) |
          EFX_RX_HASH(IPV6, 2TUPLE) }
 };
@@ -1632,10 +1645,10 @@ sfc_rx_check_mode(struct sfc_adapter *sa, struct rte_eth_rxmode *rxmode)
        int rc = 0;
 
        switch (rxmode->mq_mode) {
-       case ETH_MQ_RX_NONE:
+       case RTE_ETH_MQ_RX_NONE:
                /* No special checks are required */
                break;
-       case ETH_MQ_RX_RSS:
+       case RTE_ETH_MQ_RX_RSS:
                if (rss->context_type == EFX_RX_SCALE_UNAVAILABLE) {
                        sfc_err(sa, "RSS is not available");
                        rc = EINVAL;
@@ -1652,16 +1665,16 @@ sfc_rx_check_mode(struct sfc_adapter *sa, struct rte_eth_rxmode *rxmode)
         * so unsupported offloads cannot be added as the result of
         * below check.
         */
-       if ((rxmode->offloads & DEV_RX_OFFLOAD_CHECKSUM) !=
-           (offloads_supported & DEV_RX_OFFLOAD_CHECKSUM)) {
+       if ((rxmode->offloads & RTE_ETH_RX_OFFLOAD_CHECKSUM) !=
+           (offloads_supported & RTE_ETH_RX_OFFLOAD_CHECKSUM)) {
                sfc_warn(sa, "Rx checksum offloads cannot be disabled - always on (IPv4/TCP/UDP)");
-               rxmode->offloads |= DEV_RX_OFFLOAD_CHECKSUM;
+               rxmode->offloads |= RTE_ETH_RX_OFFLOAD_CHECKSUM;
        }
 
-       if ((offloads_supported & DEV_RX_OFFLOAD_OUTER_IPV4_CKSUM) &&
-           (~rxmode->offloads & DEV_RX_OFFLOAD_OUTER_IPV4_CKSUM)) {
+       if ((offloads_supported & RTE_ETH_RX_OFFLOAD_OUTER_IPV4_CKSUM) &&
+           (~rxmode->offloads & RTE_ETH_RX_OFFLOAD_OUTER_IPV4_CKSUM)) {
                sfc_warn(sa, "Rx outer IPv4 checksum offload cannot be disabled - always on");
-               rxmode->offloads |= DEV_RX_OFFLOAD_OUTER_IPV4_CKSUM;
+               rxmode->offloads |= RTE_ETH_RX_OFFLOAD_OUTER_IPV4_CKSUM;
        }
 
        return rc;
@@ -1807,7 +1820,7 @@ sfc_rx_configure(struct sfc_adapter *sa)
        }
 
 configure_rss:
-       rss->channels = (dev_conf->rxmode.mq_mode == ETH_MQ_RX_RSS) ?
+       rss->channels = (dev_conf->rxmode.mq_mode == RTE_ETH_MQ_RX_RSS) ?
                         MIN(sas->ethdev_rxq_count, EFX_MAXRSS) : 0;
 
        if (rss->channels > 0) {
DPDK repo used for reviews