git.droids-corp.org / dpdk.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
net/ice: fix GTPU/PPPoE packets with no hash value
[dpdk.git] / drivers / event / octeontx2 / otx2_evdev.c
diff --git a/drivers/event/octeontx2/otx2_evdev.c b/drivers/event/octeontx2/otx2_evdev.c
index f45fc00..b8b57c3 100644 (file)
--- a/drivers/event/octeontx2/otx2_evdev.c
+++ b/drivers/event/octeontx2/otx2_evdev.c
@@ -44,61 +44,64 @@ sso_fastpath_fns_set(struct rte_eventdev *event_dev)
 {
        struct otx2_sso_evdev *dev = sso_pmd_priv(event_dev);
        /* Single WS modes */
-       const event_dequeue_t ssogws_deq[2][2][2][2][2][2] = {
-#define R(name, f5, f4, f3, f2, f1, f0, flags)                         \
-               [f5][f4][f3][f2][f1][f0] = otx2_ssogws_deq_ ##name,
+       const event_dequeue_t ssogws_deq[2][2][2][2][2][2][2] = {
+#define R(name, f6, f5, f4, f3, f2, f1, f0, flags)                     \
+               [f6][f5][f4][f3][f2][f1][f0] = otx2_ssogws_deq_ ##name,
 SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
 #undef R
        };
 
-       const event_dequeue_burst_t ssogws_deq_burst[2][2][2][2][2][2] = {
-#define R(name, f5, f4, f3, f2, f1, f0, flags)                         \
-               [f5][f4][f3][f2][f1][f0] = otx2_ssogws_deq_burst_ ##name,
+       const event_dequeue_burst_t ssogws_deq_burst[2][2][2][2][2][2][2] = {
+#define R(name, f6, f5, f4, f3, f2, f1, f0, flags)                     \
+               [f6][f5][f4][f3][f2][f1][f0] = otx2_ssogws_deq_burst_ ##name,
 SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
 #undef R
        };
 
-       const event_dequeue_t ssogws_deq_timeout[2][2][2][2][2][2] = {
-#define R(name, f5, f4, f3, f2, f1, f0, flags)                         \
-               [f5][f4][f3][f2][f1][f0] = otx2_ssogws_deq_timeout_ ##name,
+       const event_dequeue_t ssogws_deq_timeout[2][2][2][2][2][2][2] = {
+#define R(name, f6, f5, f4, f3, f2, f1, f0, flags)                     \
+               [f6][f5][f4][f3][f2][f1][f0] = otx2_ssogws_deq_timeout_ ##name,
 SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
 #undef R
        };
 
        const event_dequeue_burst_t
-               ssogws_deq_timeout_burst[2][2][2][2][2][2] = {
-#define R(name, f5, f4, f3, f2, f1, f0, flags)                         \
-               [f5][f4][f3][f2][f1][f0] =                              \
+               ssogws_deq_timeout_burst[2][2][2][2][2][2][2] = {
+#define R(name, f6, f5, f4, f3, f2, f1, f0, flags)                     \
+               [f6][f5][f4][f3][f2][f1][f0] =                          \
                        otx2_ssogws_deq_timeout_burst_ ##name,
 SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
 #undef R
        };
 
-       const event_dequeue_t ssogws_deq_seg[2][2][2][2][2][2] = {
-#define R(name, f5, f4, f3, f2, f1, f0, flags)                         \
-               [f5][f4][f3][f2][f1][f0] = otx2_ssogws_deq_seg_ ##name,
+       const event_dequeue_t ssogws_deq_seg[2][2][2][2][2][2][2] = {
+#define R(name, f6, f5, f4, f3, f2, f1, f0, flags)                     \
+               [f6][f5][f4][f3][f2][f1][f0] = otx2_ssogws_deq_seg_ ##name,
 SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
 #undef R
        };
 
-       const event_dequeue_burst_t ssogws_deq_seg_burst[2][2][2][2][2][2] = {
-#define R(name, f5, f4, f3, f2, f1, f0, flags)                         \
-               [f5][f4][f3][f2][f1][f0] = otx2_ssogws_deq_seg_burst_ ##name,
+       const event_dequeue_burst_t
+               ssogws_deq_seg_burst[2][2][2][2][2][2][2] = {
+#define R(name, f6, f5, f4, f3, f2, f1, f0, flags)                     \
+               [f6][f5][f4][f3][f2][f1][f0] =                          \
+                       otx2_ssogws_deq_seg_burst_ ##name,
 SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
 #undef R
        };
 
-       const event_dequeue_t ssogws_deq_seg_timeout[2][2][2][2][2][2] = {
-#define R(name, f5, f4, f3, f2, f1, f0, flags)                         \
-               [f5][f4][f3][f2][f1][f0] = otx2_ssogws_deq_seg_timeout_ ##name,
+       const event_dequeue_t ssogws_deq_seg_timeout[2][2][2][2][2][2][2] = {
+#define R(name, f6, f5, f4, f3, f2, f1, f0, flags)                     \
+               [f6][f5][f4][f3][f2][f1][f0] =                          \
+                       otx2_ssogws_deq_seg_timeout_ ##name,
 SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
 #undef R
        };
 
        const event_dequeue_burst_t
-               ssogws_deq_seg_timeout_burst[2][2][2][2][2][2] = {
-#define R(name, f5, f4, f3, f2, f1, f0, flags)                         \
-               [f5][f4][f3][f2][f1][f0] =                              \
+               ssogws_deq_seg_timeout_burst[2][2][2][2][2][2][2] = {
+#define R(name, f6, f5, f4, f3, f2, f1, f0, flags)                     \
+               [f6][f5][f4][f3][f2][f1][f0] =                          \
                                otx2_ssogws_deq_seg_timeout_burst_ ##name,
 SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
 #undef R
@@ -106,74 +109,117 @@ SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
 
 
        /* Dual WS modes */
-       const event_dequeue_t ssogws_dual_deq[2][2][2][2][2][2] = {
-#define R(name, f5, f4, f3, f2, f1, f0, flags)                         \
-               [f5][f4][f3][f2][f1][f0] = otx2_ssogws_dual_deq_ ##name,
+       const event_dequeue_t ssogws_dual_deq[2][2][2][2][2][2][2] = {
+#define R(name, f6, f5, f4, f3, f2, f1, f0, flags)                     \
+               [f6][f5][f4][f3][f2][f1][f0] = otx2_ssogws_dual_deq_ ##name,
 SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
 #undef R
        };
 
-       const event_dequeue_burst_t ssogws_dual_deq_burst[2][2][2][2][2][2] = {
-#define R(name, f5, f4, f3, f2, f1, f0, flags)                         \
-               [f5][f4][f3][f2][f1][f0] = otx2_ssogws_dual_deq_burst_ ##name,
+       const event_dequeue_burst_t
+               ssogws_dual_deq_burst[2][2][2][2][2][2][2] = {
+#define R(name, f6, f5, f4, f3, f2, f1, f0, flags)                     \
+               [f6][f5][f4][f3][f2][f1][f0] =                          \
+                       otx2_ssogws_dual_deq_burst_ ##name,
 SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
 #undef R
        };
 
-       const event_dequeue_t ssogws_dual_deq_timeout[2][2][2][2][2][2] = {
-#define R(name, f5, f4, f3, f2, f1, f0, flags)                         \
-               [f5][f4][f3][f2][f1][f0] = otx2_ssogws_dual_deq_timeout_ ##name,
+       const event_dequeue_t ssogws_dual_deq_timeout[2][2][2][2][2][2][2] = {
+#define R(name, f6, f5, f4, f3, f2, f1, f0, flags)                     \
+               [f6][f5][f4][f3][f2][f1][f0] =                          \
+                       otx2_ssogws_dual_deq_timeout_ ##name,
 SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
 #undef R
        };
 
        const event_dequeue_burst_t
-               ssogws_dual_deq_timeout_burst[2][2][2][2][2][2] = {
-#define R(name, f5, f4, f3, f2, f1, f0, flags)                         \
-       [f5][f4][f3][f2][f1][f0] = otx2_ssogws_dual_deq_timeout_burst_ ##name,
+               ssogws_dual_deq_timeout_burst[2][2][2][2][2][2][2] = {
+#define R(name, f6, f5, f4, f3, f2, f1, f0, flags)                     \
+       [f6][f5][f4][f3][f2][f1][f0] =                                  \
+                       otx2_ssogws_dual_deq_timeout_burst_ ##name,
 SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
 #undef R
        };
 
-       const event_dequeue_t ssogws_dual_deq_seg[2][2][2][2][2][2] = {
-#define R(name, f5, f4, f3, f2, f1, f0, flags)                         \
-               [f5][f4][f3][f2][f1][f0] = otx2_ssogws_dual_deq_seg_ ##name,
+       const event_dequeue_t ssogws_dual_deq_seg[2][2][2][2][2][2][2] = {
+#define R(name, f6, f5, f4, f3, f2, f1, f0, flags)                     \
+               [f6][f5][f4][f3][f2][f1][f0] = otx2_ssogws_dual_deq_seg_ ##name,
 SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
 #undef R
        };
 
        const event_dequeue_burst_t
-               ssogws_dual_deq_seg_burst[2][2][2][2][2][2] = {
-#define R(name, f5, f4, f3, f2, f1, f0, flags)                         \
-               [f5][f4][f3][f2][f1][f0] =                              \
-                               otx2_ssogws_dual_deq_seg_burst_ ##name,
+               ssogws_dual_deq_seg_burst[2][2][2][2][2][2][2] = {
+#define R(name, f6, f5, f4, f3, f2, f1, f0, flags)                     \
+               [f6][f5][f4][f3][f2][f1][f0] =                          \
+                       otx2_ssogws_dual_deq_seg_burst_ ##name,
 SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
 #undef R
        };
 
-       const event_dequeue_t ssogws_dual_deq_seg_timeout[2][2][2][2][2][2] = {
-#define R(name, f5, f4, f3, f2, f1, f0, flags)                         \
-               [f5][f4][f3][f2][f1][f0] =                              \
-                               otx2_ssogws_dual_deq_seg_timeout_ ##name,
+       const event_dequeue_t
+               ssogws_dual_deq_seg_timeout[2][2][2][2][2][2][2] = {
+#define R(name, f6, f5, f4, f3, f2, f1, f0, flags)                     \
+               [f6][f5][f4][f3][f2][f1][f0] =                          \
+                       otx2_ssogws_dual_deq_seg_timeout_ ##name,
 SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
 #undef R
        };
 
        const event_dequeue_burst_t
-               ssogws_dual_deq_seg_timeout_burst[2][2][2][2][2][2] = {
-#define R(name, f5, f4, f3, f2, f1, f0, flags)                         \
-       [f5][f4][f3][f2][f1][f0] =                                      \
-               otx2_ssogws_dual_deq_seg_timeout_burst_ ##name,
+               ssogws_dual_deq_seg_timeout_burst[2][2][2][2][2][2][2] = {
+#define R(name, f6, f5, f4, f3, f2, f1, f0, flags)                     \
+               [f6][f5][f4][f3][f2][f1][f0] =                          \
+                       otx2_ssogws_dual_deq_seg_timeout_burst_ ##name,
 SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
 #undef R
        };
 
+       /* Tx modes */
+       const event_tx_adapter_enqueue
+               ssogws_tx_adptr_enq[2][2][2][2][2][2][2] = {
+#define T(name, f6, f5, f4, f3, f2, f1, f0, sz, flags)                 \
+               [f6][f5][f4][f3][f2][f1][f0] =                          \
+                       otx2_ssogws_tx_adptr_enq_ ## name,
+SSO_TX_ADPTR_ENQ_FASTPATH_FUNC
+#undef T
+       };
+
+       const event_tx_adapter_enqueue
+               ssogws_tx_adptr_enq_seg[2][2][2][2][2][2][2] = {
+#define T(name, f6, f5, f4, f3, f2, f1, f0, sz, flags)                 \
+               [f6][f5][f4][f3][f2][f1][f0] =                          \
+                       otx2_ssogws_tx_adptr_enq_seg_ ## name,
+SSO_TX_ADPTR_ENQ_FASTPATH_FUNC
+#undef T
+       };
+
+       const event_tx_adapter_enqueue
+               ssogws_dual_tx_adptr_enq[2][2][2][2][2][2][2] = {
+#define T(name, f6, f5, f4, f3, f2, f1, f0, sz, flags)                 \
+               [f6][f5][f4][f3][f2][f1][f0] =                          \
+                       otx2_ssogws_dual_tx_adptr_enq_ ## name,
+SSO_TX_ADPTR_ENQ_FASTPATH_FUNC
+#undef T
+       };
+
+       const event_tx_adapter_enqueue
+               ssogws_dual_tx_adptr_enq_seg[2][2][2][2][2][2][2] = {
+#define T(name, f6, f5, f4, f3, f2, f1, f0, sz, flags)                 \
+               [f6][f5][f4][f3][f2][f1][f0] =                          \
+                       otx2_ssogws_dual_tx_adptr_enq_seg_ ## name,
+SSO_TX_ADPTR_ENQ_FASTPATH_FUNC
+#undef T
+       };
+
        event_dev->enqueue                      = otx2_ssogws_enq;
        event_dev->enqueue_burst                = otx2_ssogws_enq_burst;
        event_dev->enqueue_new_burst            = otx2_ssogws_enq_new_burst;
        event_dev->enqueue_forward_burst        = otx2_ssogws_enq_fwd_burst;
        if (dev->rx_offloads & NIX_RX_MULTI_SEG_F) {
                event_dev->dequeue              = ssogws_deq_seg
+                       [!!(dev->rx_offloads & NIX_RX_OFFLOAD_SECURITY_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_TSTAMP_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_MARK_UPDATE_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_VLAN_STRIP_F)]
@@ -181,6 +227,7 @@ SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_PTYPE_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_RSS_F)];
                event_dev->dequeue_burst        = ssogws_deq_seg_burst
+                       [!!(dev->rx_offloads & NIX_RX_OFFLOAD_SECURITY_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_TSTAMP_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_MARK_UPDATE_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_VLAN_STRIP_F)]
@@ -189,6 +236,7 @@ SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_RSS_F)];
                if (dev->is_timeout_deq) {
                        event_dev->dequeue      = ssogws_deq_seg_timeout
+                       [!!(dev->rx_offloads & NIX_RX_OFFLOAD_SECURITY_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_TSTAMP_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_MARK_UPDATE_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_VLAN_STRIP_F)]
@@ -197,6 +245,7 @@ SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_RSS_F)];
                        event_dev->dequeue_burst        =
                                ssogws_deq_seg_timeout_burst
+                       [!!(dev->rx_offloads & NIX_RX_OFFLOAD_SECURITY_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_TSTAMP_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_MARK_UPDATE_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_VLAN_STRIP_F)]
@@ -206,6 +255,7 @@ SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
                }
        } else {
                event_dev->dequeue                      = ssogws_deq
+                       [!!(dev->rx_offloads & NIX_RX_OFFLOAD_SECURITY_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_TSTAMP_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_MARK_UPDATE_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_VLAN_STRIP_F)]
@@ -213,6 +263,7 @@ SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_PTYPE_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_RSS_F)];
                event_dev->dequeue_burst                = ssogws_deq_burst
+                       [!!(dev->rx_offloads & NIX_RX_OFFLOAD_SECURITY_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_TSTAMP_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_MARK_UPDATE_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_VLAN_STRIP_F)]
@@ -221,6 +272,7 @@ SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_RSS_F)];
                if (dev->is_timeout_deq) {
                        event_dev->dequeue              = ssogws_deq_timeout
+                       [!!(dev->rx_offloads & NIX_RX_OFFLOAD_SECURITY_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_TSTAMP_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_MARK_UPDATE_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_VLAN_STRIP_F)]
@@ -229,6 +281,7 @@ SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_RSS_F)];
                        event_dev->dequeue_burst        =
                                ssogws_deq_timeout_burst
+                       [!!(dev->rx_offloads & NIX_RX_OFFLOAD_SECURITY_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_TSTAMP_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_MARK_UPDATE_F)]
                        [!!(dev->rx_offloads & NIX_RX_OFFLOAD_VLAN_STRIP_F)]
@@ -238,6 +291,27 @@ SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
                }
        }
 
+       if (dev->tx_offloads & NIX_TX_MULTI_SEG_F) {
+               /* [SEC] [TSMP] [MBUF_NOFF] [VLAN] [OL3_L4_CSUM] [L3_L4_CSUM] */
+               event_dev->txa_enqueue = ssogws_tx_adptr_enq_seg
+                       [!!(dev->tx_offloads & NIX_TX_OFFLOAD_SECURITY_F)]
+                       [!!(dev->tx_offloads & NIX_TX_OFFLOAD_TSO_F)]
+                       [!!(dev->tx_offloads & NIX_TX_OFFLOAD_TSTAMP_F)]
+                       [!!(dev->tx_offloads & NIX_TX_OFFLOAD_MBUF_NOFF_F)]
+                       [!!(dev->tx_offloads & NIX_TX_OFFLOAD_VLAN_QINQ_F)]
+                       [!!(dev->tx_offloads & NIX_TX_OFFLOAD_OL3_OL4_CSUM_F)]
+                       [!!(dev->tx_offloads & NIX_TX_OFFLOAD_L3_L4_CSUM_F)];
+       } else {
+               event_dev->txa_enqueue = ssogws_tx_adptr_enq
+                       [!!(dev->tx_offloads & NIX_TX_OFFLOAD_SECURITY_F)]
+                       [!!(dev->tx_offloads & NIX_TX_OFFLOAD_TSO_F)]
+                       [!!(dev->tx_offloads & NIX_TX_OFFLOAD_TSTAMP_F)]
+                       [!!(dev->tx_offloads & NIX_TX_OFFLOAD_MBUF_NOFF_F)]
+                       [!!(dev->tx_offloads & NIX_TX_OFFLOAD_VLAN_QINQ_F)]
+                       [!!(dev->tx_offloads & NIX_TX_OFFLOAD_OL3_OL4_CSUM_F)]
+                       [!!(dev->tx_offloads & NIX_TX_OFFLOAD_L3_L4_CSUM_F)];
+       }
+
        if (dev->dual_ws) {
                event_dev->enqueue              = otx2_ssogws_dual_enq;
                event_dev->enqueue_burst        = otx2_ssogws_dual_enq_burst;
@@ -248,6 +322,8 @@ SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
 
                if (dev->rx_offloads & NIX_RX_MULTI_SEG_F) {
                        event_dev->dequeue      = ssogws_dual_deq_seg
+                               [!!(dev->rx_offloads &
+                                               NIX_RX_OFFLOAD_SECURITY_F)]
                                [!!(dev->rx_offloads &
                                                NIX_RX_OFFLOAD_TSTAMP_F)]
                                [!!(dev->rx_offloads &
@@ -259,6 +335,8 @@ SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
                                [!!(dev->rx_offloads & NIX_RX_OFFLOAD_PTYPE_F)]
                                [!!(dev->rx_offloads & NIX_RX_OFFLOAD_RSS_F)];
                        event_dev->dequeue_burst = ssogws_dual_deq_seg_burst
+                               [!!(dev->rx_offloads &
+                                               NIX_RX_OFFLOAD_SECURITY_F)]
                                [!!(dev->rx_offloads & NIX_RX_OFFLOAD_TSTAMP_F)]
                                [!!(dev->rx_offloads &
                                                NIX_RX_OFFLOAD_MARK_UPDATE_F)]
@@ -271,6 +349,8 @@ SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
                        if (dev->is_timeout_deq) {
                                event_dev->dequeue      =
                                        ssogws_dual_deq_seg_timeout
+                                       [!!(dev->rx_offloads &
+                                               NIX_RX_OFFLOAD_SECURITY_F)]
                                        [!!(dev->rx_offloads &
                                                NIX_RX_OFFLOAD_TSTAMP_F)]
                                        [!!(dev->rx_offloads &
@@ -285,6 +365,8 @@ SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
                                                        NIX_RX_OFFLOAD_RSS_F)];
                                event_dev->dequeue_burst =
                                        ssogws_dual_deq_seg_timeout_burst
+                                       [!!(dev->rx_offloads &
+                                               NIX_RX_OFFLOAD_SECURITY_F)]
                                        [!!(dev->rx_offloads &
                                                NIX_RX_OFFLOAD_TSTAMP_F)]
                                        [!!(dev->rx_offloads &
@@ -300,6 +382,8 @@ SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
                        }
                } else {
                        event_dev->dequeue              = ssogws_dual_deq
+                               [!!(dev->rx_offloads &
+                                               NIX_RX_OFFLOAD_SECURITY_F)]
                                [!!(dev->rx_offloads &
                                                NIX_RX_OFFLOAD_TSTAMP_F)]
                                [!!(dev->rx_offloads &
@@ -311,6 +395,8 @@ SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
                                [!!(dev->rx_offloads & NIX_RX_OFFLOAD_PTYPE_F)]
                                [!!(dev->rx_offloads & NIX_RX_OFFLOAD_RSS_F)];
                        event_dev->dequeue_burst        = ssogws_dual_deq_burst
+                               [!!(dev->rx_offloads &
+                                               NIX_RX_OFFLOAD_SECURITY_F)]
                                [!!(dev->rx_offloads &
                                                NIX_RX_OFFLOAD_TSTAMP_F)]
                                [!!(dev->rx_offloads &
@@ -324,6 +410,8 @@ SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
                        if (dev->is_timeout_deq) {
                                event_dev->dequeue      =
                                        ssogws_dual_deq_timeout
+                                       [!!(dev->rx_offloads &
+                                               NIX_RX_OFFLOAD_SECURITY_F)]
                                        [!!(dev->rx_offloads &
                                                NIX_RX_OFFLOAD_TSTAMP_F)]
                                        [!!(dev->rx_offloads &
@@ -338,6 +426,8 @@ SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
                                                        NIX_RX_OFFLOAD_RSS_F)];
                                event_dev->dequeue_burst =
                                        ssogws_dual_deq_timeout_burst
+                                       [!!(dev->rx_offloads &
+                                               NIX_RX_OFFLOAD_SECURITY_F)]
                                        [!!(dev->rx_offloads &
                                                NIX_RX_OFFLOAD_TSTAMP_F)]
                                        [!!(dev->rx_offloads &
@@ -352,7 +442,40 @@ SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
                                                        NIX_RX_OFFLOAD_RSS_F)];
                        }
                }
+
+               if (dev->tx_offloads & NIX_TX_MULTI_SEG_F) {
+               /* [SEC] [TSMP] [MBUF_NOFF] [VLAN] [OL3_L4_CSUM] [L3_L4_CSUM] */
+                       event_dev->txa_enqueue = ssogws_dual_tx_adptr_enq_seg
+                               [!!(dev->tx_offloads &
+                                               NIX_TX_OFFLOAD_SECURITY_F)]
+                               [!!(dev->tx_offloads & NIX_TX_OFFLOAD_TSO_F)]
+                               [!!(dev->tx_offloads & NIX_TX_OFFLOAD_TSTAMP_F)]
+                               [!!(dev->tx_offloads &
+                                               NIX_TX_OFFLOAD_MBUF_NOFF_F)]
+                               [!!(dev->tx_offloads &
+                                               NIX_TX_OFFLOAD_VLAN_QINQ_F)]
+                               [!!(dev->tx_offloads &
+                                               NIX_TX_OFFLOAD_OL3_OL4_CSUM_F)]
+                               [!!(dev->tx_offloads &
+                                               NIX_TX_OFFLOAD_L3_L4_CSUM_F)];
+               } else {
+                       event_dev->txa_enqueue = ssogws_dual_tx_adptr_enq
+                               [!!(dev->tx_offloads &
+                                               NIX_TX_OFFLOAD_SECURITY_F)]
+                               [!!(dev->tx_offloads & NIX_TX_OFFLOAD_TSO_F)]
+                               [!!(dev->tx_offloads & NIX_TX_OFFLOAD_TSTAMP_F)]
+                               [!!(dev->tx_offloads &
+                                               NIX_TX_OFFLOAD_MBUF_NOFF_F)]
+                               [!!(dev->tx_offloads &
+                                               NIX_TX_OFFLOAD_VLAN_QINQ_F)]
+                               [!!(dev->tx_offloads &
+                                               NIX_TX_OFFLOAD_OL3_OL4_CSUM_F)]
+                               [!!(dev->tx_offloads &
+                                               NIX_TX_OFFLOAD_L3_L4_CSUM_F)];
+               }
        }
+
+       event_dev->txa_enqueue_same_dest = event_dev->txa_enqueue;
        rte_mb();
 }
 
@@ -602,6 +725,46 @@ sso_clr_links(const struct rte_eventdev *event_dev)
        }
 }
 
+static void
+sso_restore_links(const struct rte_eventdev *event_dev)
+{
+       struct otx2_sso_evdev *dev = sso_pmd_priv(event_dev);
+       uint16_t *links_map;
+       int i, j;
+
+       for (i = 0; i < dev->nb_event_ports; i++) {
+               links_map = event_dev->data->links_map;
+               /* Point links_map to this port specific area */
+               links_map += (i * RTE_EVENT_MAX_QUEUES_PER_DEV);
+               if (dev->dual_ws) {
+                       struct otx2_ssogws_dual *ws;
+
+                       ws = event_dev->data->ports[i];
+                       for (j = 0; j < dev->nb_event_queues; j++) {
+                               if (links_map[j] == 0xdead)
+                                       continue;
+                               sso_port_link_modify((struct otx2_ssogws *)
+                                               &ws->ws_state[0], j, true);
+                               sso_port_link_modify((struct otx2_ssogws *)
+                                               &ws->ws_state[1], j, true);
+                               sso_func_trace("Restoring port %d queue %d "
+                                               "link", i, j);
+                       }
+               } else {
+                       struct otx2_ssogws *ws;
+
+                       ws = event_dev->data->ports[i];
+                       for (j = 0; j < dev->nb_event_queues; j++) {
+                               if (links_map[j] == 0xdead)
+                                       continue;
+                               sso_port_link_modify(ws, j, true);
+                               sso_func_trace("Restoring port %d queue %d "
+                                               "link", i, j);
+                       }
+               }
+       }
+}
+
 static void
 sso_set_port_ops(struct otx2_ssogws *ws, uintptr_t base)
 {
@@ -642,18 +805,15 @@ sso_configure_dual_ports(const struct rte_eventdev *event_dev)
                struct otx2_ssogws_dual *ws;
                uintptr_t base;
 
-               /* Free memory prior to re-allocation if needed */
                if (event_dev->data->ports[i] != NULL) {
                        ws = event_dev->data->ports[i];
-                       rte_free(ws);
-                       ws = NULL;
-               }
-
-               /* Allocate event port memory */
-               ws = rte_zmalloc_socket("otx2_sso_ws",
+               } else {
+                       /* Allocate event port memory */
+                       ws = rte_zmalloc_socket("otx2_sso_ws",
                                        sizeof(struct otx2_ssogws_dual),
                                        RTE_CACHE_LINE_SIZE,
                                        event_dev->data->socket_id);
+               }
                if (ws == NULL) {
                        otx2_err("Failed to alloc memory for port=%d", i);
                        rc = -ENOMEM;
@@ -938,8 +1098,11 @@ otx2_sso_configure(const struct rte_eventdev *event_dev)
                return -EINVAL;
        }
 
-       if (dev->configured)
+       if (dev->configured) {
                sso_unregister_irqs(event_dev);
+               /* Clear any prior port-queue mapping. */
+               sso_clr_links(event_dev);
+       }
 
        if (dev->nb_event_queues) {
                /* Finit any previous queues. */
@@ -974,8 +1137,8 @@ otx2_sso_configure(const struct rte_eventdev *event_dev)
                goto teardown_hwggrp;
        }
 
-       /* Clear any prior port-queue mapping. */
-       sso_clr_links(event_dev);
+       /* Restore any prior port-queue mapping. */
+       sso_restore_links(event_dev);
        rc = sso_ggrp_alloc_xaq(dev);
        if (rc < 0) {
                otx2_err("Failed to alloc xaq to ggrp %d", rc);
@@ -1095,6 +1258,7 @@ otx2_sso_port_setup(struct rte_eventdev *event_dev, uint8_t port_id,
                           sizeof(uintptr_t) * OTX2_SSO_MAX_VHGRP);
                ws->fc_mem = dev->fc_mem;
                ws->xaq_lmt = dev->xaq_lmt;
+               ws->tstamp = dev->tstamp;
                otx2_write64(val, OTX2_SSOW_GET_BASE_ADDR(
                             ws->ws_state[0].getwrk_op) + SSOW_LF_GWS_NW_TIM);
                otx2_write64(val, OTX2_SSOW_GET_BASE_ADDR(
@@ -1107,6 +1271,7 @@ otx2_sso_port_setup(struct rte_eventdev *event_dev, uint8_t port_id,
                           sizeof(uintptr_t) * OTX2_SSO_MAX_VHGRP);
                ws->fc_mem = dev->fc_mem;
                ws->xaq_lmt = dev->xaq_lmt;
+               ws->tstamp = dev->tstamp;
                otx2_write64(val, base + SSOW_LF_GWS_NW_TIM);
        }
 
@@ -1327,7 +1492,12 @@ sso_xae_reconfigure(struct rte_eventdev *event_dev)
 
        prev_xaq_pool = dev->xaq_pool;
        dev->xaq_pool = NULL;
-       sso_xaq_allocate(dev);
+       rc = sso_xaq_allocate(dev);
+       if (rc < 0) {
+               otx2_err("Failed to alloc xaq pool %d", rc);
+               rte_mempool_free(prev_xaq_pool);
+               return rc;
+       }
        rc = sso_ggrp_alloc_xaq(dev);
        if (rc < 0) {
                otx2_err("Failed to alloc xaq to ggrp %d", rc);
@@ -1411,6 +1581,10 @@ static struct rte_eventdev_ops otx2_sso_ops = {
        .eth_rx_adapter_start = otx2_sso_rx_adapter_start,
        .eth_rx_adapter_stop = otx2_sso_rx_adapter_stop,
 
+       .eth_tx_adapter_caps_get = otx2_sso_tx_adapter_caps_get,
+       .eth_tx_adapter_queue_add = otx2_sso_tx_adapter_queue_add,
+       .eth_tx_adapter_queue_del = otx2_sso_tx_adapter_queue_del,
+
        .timer_adapter_caps_get = otx2_tim_caps_get,
 
        .xstats_get       = otx2_sso_xstats_get,
@@ -1436,6 +1610,7 @@ parse_queue_param(char *value, void *opaque)
        uint8_t *val = (uint8_t *)&queue_qos;
        struct otx2_sso_evdev *dev = opaque;
        char *tok = strtok(value, "-");
+       struct otx2_sso_qos *old_ptr;
 
        if (!strlen(value))
                return;
@@ -1452,9 +1627,15 @@ parse_queue_param(char *value, void *opaque)
        }
 
        dev->qos_queue_cnt++;
+       old_ptr = dev->qos_parse_data;
        dev->qos_parse_data = rte_realloc(dev->qos_parse_data,
                                          sizeof(struct otx2_sso_qos) *
                                          dev->qos_queue_cnt, 0);
+       if (dev->qos_parse_data == NULL) {
+               dev->qos_parse_data = old_ptr;
+               dev->qos_queue_cnt--;
+               return;
+       }
        dev->qos_parse_data[dev->qos_queue_cnt - 1] = queue_qos;
 }
 
@@ -1472,7 +1653,7 @@ parse_qos_list(const char *value, void *opaque)
                else if (*s == ']')
                        end = s;
 
-               if (start < end && *start) {
+               if (start && start < end) {
                        *end = 0;
                        parse_queue_param(start + 1, opaque);
                        s = end;
@@ -1518,7 +1699,7 @@ sso_parse_devargs(struct otx2_sso_evdev *dev, struct rte_devargs *devargs)
                           &single_ws);
        rte_kvargs_process(kvlist, OTX2_SSO_GGRP_QOS, &parse_sso_kvargs_dict,
                           dev);
-
+       otx2_parse_common_devargs(kvlist);
        dev->dual_ws = !single_ws;
        rte_kvargs_free(kvlist);
 }
@@ -1549,7 +1730,7 @@ static const struct rte_pci_id pci_sso_map[] = {
 
 static struct rte_pci_driver pci_sso = {
        .id_table = pci_sso_map,
-       .drv_flags = RTE_PCI_DRV_NEED_MAPPING | RTE_PCI_DRV_IOVA_AS_VA,
+       .drv_flags = RTE_PCI_DRV_NEED_MAPPING | RTE_PCI_DRV_NEED_IOVA_AS_VA,
        .probe = otx2_sso_probe,
        .remove = otx2_sso_remove,
 };
@@ -1680,4 +1861,5 @@ RTE_PMD_REGISTER_KMOD_DEP(event_octeontx2, "vfio-pci");
 RTE_PMD_REGISTER_PARAM_STRING(event_octeontx2, OTX2_SSO_XAE_CNT "=<int>"
                              OTX2_SSO_SINGLE_WS "=1"
                              OTX2_SSO_GGRP_QOS "=<string>"
-                             OTX2_SSO_SELFTEST "=1");
+                             OTX2_SSO_SELFTEST "=1"
+                             OTX2_NPA_LOCK_MASK "=<1-65535>");
DPDK repo used for reviews