git.droids-corp.org / dpdk.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
vhost: fix offload flags in Rx path
[dpdk.git] / drivers / net / ice / ice_rxtx.c
diff --git a/drivers/net/ice/ice_rxtx.c b/drivers/net/ice/ice_rxtx.c
index 4136d04..92fbbc1 100644 (file)
--- a/drivers/net/ice/ice_rxtx.c
+++ b/drivers/net/ice/ice_rxtx.c
@@ -8,6 +8,7 @@
 
 #include "rte_pmd_ice.h"
 #include "ice_rxtx.h"
+#include "ice_rxtx_vec_common.h"
 
 #define ICE_TX_CKSUM_OFFLOAD_MASK (             \
                PKT_TX_IP_CKSUM |                \
@@ -1058,6 +1059,7 @@ ice_rx_queue_setup(struct rte_eth_dev *dev,
        uint32_t ring_size;
        uint16_t len;
        int use_def_burst_func = 1;
+       uint64_t offloads;
 
        if (nb_desc % ICE_ALIGN_RING_DESC != 0 ||
            nb_desc > ICE_MAX_RING_DESC ||
@@ -1067,6 +1069,8 @@ ice_rx_queue_setup(struct rte_eth_dev *dev,
                return -EINVAL;
        }
 
+       offloads = rx_conf->offloads | dev->data->dev_conf.rxmode.offloads;
+
        /* Free memory if needed */
        if (dev->data->rx_queues[queue_idx]) {
                ice_rx_queue_release(dev->data->rx_queues[queue_idx]);
@@ -1087,6 +1091,7 @@ ice_rx_queue_setup(struct rte_eth_dev *dev,
        rxq->nb_rx_desc = nb_desc;
        rxq->rx_free_thresh = rx_conf->rx_free_thresh;
        rxq->queue_id = queue_idx;
+       rxq->offloads = offloads;
 
        rxq->reg_idx = vsi->base_queue + queue_idx;
        rxq->port_id = dev->data->port_id;
@@ -1475,7 +1480,7 @@ ice_rxd_error_to_pkt_flags(uint16_t stat_err0)
                flags |= PKT_RX_L4_CKSUM_GOOD;
 
        if (unlikely(stat_err0 & (1 << ICE_RX_FLEX_DESC_STATUS0_XSUM_EIPE_S)))
-               flags |= PKT_RX_EIP_CKSUM_BAD;
+               flags |= PKT_RX_OUTER_IP_CKSUM_BAD;
 
        if (unlikely(stat_err0 & (1 << ICE_RX_FLEX_DESC_STATUS0_XSUM_EUDPE_S)))
                flags |= PKT_RX_OUTER_L4_CKSUM_BAD;
@@ -1989,7 +1994,9 @@ ice_dev_supported_ptypes_get(struct rte_eth_dev *dev)
            dev->rx_pkt_burst == ice_recv_scattered_pkts_vec ||
 #ifdef CC_AVX512_SUPPORT
            dev->rx_pkt_burst == ice_recv_pkts_vec_avx512 ||
+           dev->rx_pkt_burst == ice_recv_pkts_vec_avx512_offload ||
            dev->rx_pkt_burst == ice_recv_scattered_pkts_vec_avx512 ||
+           dev->rx_pkt_burst == ice_recv_scattered_pkts_vec_avx512_offload ||
 #endif
            dev->rx_pkt_burst == ice_recv_pkts_vec_avx2 ||
            dev->rx_pkt_burst == ice_recv_scattered_pkts_vec_avx2)
@@ -2436,11 +2443,11 @@ ice_xmit_cleanup(struct ice_tx_queue *txq)
        desc_to_clean_to = sw_ring[desc_to_clean_to].last_id;
        if (!(txd[desc_to_clean_to].cmd_type_offset_bsz &
            rte_cpu_to_le_64(ICE_TX_DESC_DTYPE_DESC_DONE))) {
-               PMD_TX_FREE_LOG(DEBUG, "TX descriptor %4u is not done "
-                               "(port=%d queue=%d) value=0x%"PRIx64"\n",
-                               desc_to_clean_to,
-                               txq->port_id, txq->queue_id,
-                               txd[desc_to_clean_to].cmd_type_offset_bsz);
+               PMD_TX_LOG(DEBUG, "TX descriptor %4u is not done "
+                          "(port=%d queue=%d) value=0x%"PRIx64"\n",
+                          desc_to_clean_to,
+                          txq->port_id, txq->queue_id,
+                          txd[desc_to_clean_to].cmd_type_offset_bsz);
                /* Failed to clean any descriptors */
                return -1;
        }
@@ -2731,10 +2738,10 @@ ice_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts, uint16_t nb_pkts)
 
                /* set RS bit on the last descriptor of one packet */
                if (txq->nb_tx_used >= txq->tx_rs_thresh) {
-                       PMD_TX_FREE_LOG(DEBUG,
-                                       "Setting RS bit on TXD id="
-                                       "%4u (port=%d queue=%d)",
-                                       tx_last, txq->port_id, txq->queue_id);
+                       PMD_TX_LOG(DEBUG,
+                                  "Setting RS bit on TXD id="
+                                  "%4u (port=%d queue=%d)",
+                                  tx_last, txq->port_id, txq->queue_id);
 
                        td_cmd |= ICE_TX_DESC_CMD_RS;
 
@@ -3051,12 +3058,14 @@ ice_set_rx_function(struct rte_eth_dev *dev)
 #ifdef RTE_ARCH_X86
        struct ice_rx_queue *rxq;
        int i;
+       int rx_check_ret;
        bool use_avx512 = false;
        bool use_avx2 = false;
 
        if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
-               if (!ice_rx_vec_dev_check(dev) && ad->rx_bulk_alloc_allowed &&
-                               rte_vect_get_max_simd_bitwidth() >= RTE_VECT_SIMD_128) {
+               rx_check_ret = ice_rx_vec_dev_check(dev);
+               if (rx_check_ret >= 0 && ad->rx_bulk_alloc_allowed &&
+                   rte_vect_get_max_simd_bitwidth() >= RTE_VECT_SIMD_128) {
                        ad->rx_vec_allowed = true;
                        for (i = 0; i < dev->data->nb_rx_queues; i++) {
                                rxq = dev->data->rx_queues[i];
@@ -3090,11 +3099,19 @@ ice_set_rx_function(struct rte_eth_dev *dev)
                if (dev->data->scattered_rx) {
                        if (use_avx512) {
 #ifdef CC_AVX512_SUPPORT
-                               PMD_DRV_LOG(NOTICE,
-                                       "Using AVX512 Vector Scattered Rx (port %d).",
-                                       dev->data->port_id);
-                               dev->rx_pkt_burst =
-                                       ice_recv_scattered_pkts_vec_avx512;
+                               if (rx_check_ret == ICE_VECTOR_OFFLOAD_PATH) {
+                                       PMD_DRV_LOG(NOTICE,
+                                               "Using AVX512 OFFLOAD Vector Scattered Rx (port %d).",
+                                               dev->data->port_id);
+                                       dev->rx_pkt_burst =
+                                               ice_recv_scattered_pkts_vec_avx512_offload;
+                               } else {
+                                       PMD_DRV_LOG(NOTICE,
+                                               "Using AVX512 Vector Scattered Rx (port %d).",
+                                               dev->data->port_id);
+                                       dev->rx_pkt_burst =
+                                               ice_recv_scattered_pkts_vec_avx512;
+                               }
 #endif
                        } else {
                                PMD_DRV_LOG(DEBUG,
@@ -3108,11 +3125,19 @@ ice_set_rx_function(struct rte_eth_dev *dev)
                } else {
                        if (use_avx512) {
 #ifdef CC_AVX512_SUPPORT
-                               PMD_DRV_LOG(NOTICE,
-                                       "Using AVX512 Vector Rx (port %d).",
-                                       dev->data->port_id);
-                               dev->rx_pkt_burst =
-                                       ice_recv_pkts_vec_avx512;
+                               if (rx_check_ret == ICE_VECTOR_OFFLOAD_PATH) {
+                                       PMD_DRV_LOG(NOTICE,
+                                               "Using AVX512 OFFLOAD Vector Rx (port %d).",
+                                               dev->data->port_id);
+                                       dev->rx_pkt_burst =
+                                               ice_recv_pkts_vec_avx512_offload;
+                               } else {
+                                       PMD_DRV_LOG(NOTICE,
+                                               "Using AVX512 Vector Rx (port %d).",
+                                               dev->data->port_id);
+                                       dev->rx_pkt_burst =
+                                               ice_recv_pkts_vec_avx512;
+                               }
 #endif
                        } else {
                                PMD_DRV_LOG(DEBUG,
@@ -3161,7 +3186,9 @@ static const struct {
 #ifdef RTE_ARCH_X86
 #ifdef CC_AVX512_SUPPORT
        { ice_recv_scattered_pkts_vec_avx512, "Vector AVX512 Scattered" },
+       { ice_recv_scattered_pkts_vec_avx512_offload, "Offload Vector AVX512 Scattered" },
        { ice_recv_pkts_vec_avx512,           "Vector AVX512" },
+       { ice_recv_pkts_vec_avx512_offload,   "Offload Vector AVX512" },
 #endif
        { ice_recv_scattered_pkts_vec_avx2, "Vector AVX2 Scattered" },
        { ice_recv_pkts_vec_avx2,           "Vector AVX2" },
@@ -3243,7 +3270,7 @@ ice_prep_pkts(__rte_unused void *tx_queue, struct rte_mbuf **tx_pkts,
                        return i;
                }
 
-#ifdef RTE_LIBRTE_ETHDEV_DEBUG
+#ifdef RTE_ETHDEV_DEBUG_TX
                ret = rte_validate_tx_offload(m);
                if (ret != 0) {
                        rte_errno = -ret;
@@ -3267,12 +3294,14 @@ ice_set_tx_function(struct rte_eth_dev *dev)
 #ifdef RTE_ARCH_X86
        struct ice_tx_queue *txq;
        int i;
+       int tx_check_ret;
        bool use_avx512 = false;
        bool use_avx2 = false;
 
        if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
-               if (!ice_tx_vec_dev_check(dev) &&
-                               rte_vect_get_max_simd_bitwidth() >= RTE_VECT_SIMD_128) {
+               tx_check_ret = ice_tx_vec_dev_check(dev);
+               if (tx_check_ret >= 0 &&
+                   rte_vect_get_max_simd_bitwidth() >= RTE_VECT_SIMD_128) {
                        ad->tx_vec_allowed = true;
                        for (i = 0; i < dev->data->nb_tx_queues; i++) {
                                txq = dev->data->tx_queues[i];
@@ -3291,12 +3320,15 @@ ice_set_tx_function(struct rte_eth_dev *dev)
                        PMD_DRV_LOG(NOTICE,
                                "AVX512 is not supported in build env");
 #endif
-                       if (!use_avx512 &&
+                       if (!use_avx512 && tx_check_ret == ICE_VECTOR_PATH &&
                        (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX2) == 1 ||
                        rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX512F) == 1) &&
                        rte_vect_get_max_simd_bitwidth() >= RTE_VECT_SIMD_256)
                                use_avx2 = true;
 
+                       if (!use_avx512 && tx_check_ret == ICE_VECTOR_OFFLOAD_PATH)
+                               ad->tx_vec_allowed = false;
+
                } else {
                        ad->tx_vec_allowed = false;
                }
@@ -3305,9 +3337,18 @@ ice_set_tx_function(struct rte_eth_dev *dev)
        if (ad->tx_vec_allowed) {
                if (use_avx512) {
 #ifdef CC_AVX512_SUPPORT
-                       PMD_DRV_LOG(NOTICE, "Using AVX512 Vector Tx (port %d).",
-                                   dev->data->port_id);
-                       dev->tx_pkt_burst = ice_xmit_pkts_vec_avx512;
+                       if (tx_check_ret == ICE_VECTOR_OFFLOAD_PATH) {
+                               PMD_DRV_LOG(NOTICE,
+                                           "Using AVX512 OFFLOAD Vector Tx (port %d).",
+                                           dev->data->port_id);
+                               dev->tx_pkt_burst =
+                                       ice_xmit_pkts_vec_avx512_offload;
+                       } else {
+                               PMD_DRV_LOG(NOTICE,
+                                           "Using AVX512 Vector Tx (port %d).",
+                                           dev->data->port_id);
+                               dev->tx_pkt_burst = ice_xmit_pkts_vec_avx512;
+                       }
 #endif
                } else {
                        PMD_DRV_LOG(DEBUG, "Using %sVector Tx (port %d).",
@@ -3343,6 +3384,7 @@ static const struct {
 #ifdef RTE_ARCH_X86
 #ifdef CC_AVX512_SUPPORT
        { ice_xmit_pkts_vec_avx512, "Vector AVX512" },
+       { ice_xmit_pkts_vec_avx512_offload, "Offload Vector AVX512" },
 #endif
        { ice_xmit_pkts_vec_avx2, "Vector AVX2" },
        { ice_xmit_pkts_vec,      "Vector SSE" },
DPDK repo used for reviews