mbuf: add rte prefix to offload flags
[dpdk.git] / drivers / net / octeontx2 / otx2_tx.h
index 486248d..c9558e5 100644 (file)
@@ -29,8 +29,8 @@
         NIX_TX_OFFLOAD_TSO_F)
 
 #define NIX_UDP_TUN_BITMASK \
-       ((1ull << (PKT_TX_TUNNEL_VXLAN >> 45)) | \
-        (1ull << (PKT_TX_TUNNEL_GENEVE >> 45)))
+       ((1ull << (RTE_MBUF_F_TX_TUNNEL_VXLAN >> 45)) | \
+        (1ull << (RTE_MBUF_F_TX_TUNNEL_GENEVE >> 45)))
 
 #define NIX_LSO_FORMAT_IDX_TSOV4       (0)
 #define NIX_LSO_FORMAT_IDX_TSOV6       (1)
@@ -54,7 +54,7 @@ otx2_nix_xmit_prepare_tstamp(uint64_t *cmd,  const uint64_t *send_mem_desc,
        if (flags & NIX_TX_OFFLOAD_TSTAMP_F) {
                struct nix_send_mem_s *send_mem;
                uint16_t off = (no_segdw - 1) << 1;
-               const uint8_t is_ol_tstamp = !(ol_flags & PKT_TX_IEEE1588_TMST);
+               const uint8_t is_ol_tstamp = !(ol_flags & RTE_MBUF_F_TX_IEEE1588_TMST);
 
                send_mem = (struct nix_send_mem_s *)(cmd + off);
                if (flags & NIX_TX_MULTI_SEG_F) {
@@ -67,7 +67,7 @@ otx2_nix_xmit_prepare_tstamp(uint64_t *cmd,  const uint64_t *send_mem_desc,
                        rte_compiler_barrier();
                }
 
-               /* Packets for which PKT_TX_IEEE1588_TMST is not set, tx tstamp
+               /* Packets for which RTE_MBUF_F_TX_IEEE1588_TMST is not set, tx tstamp
                 * should not be recorded, hence changing the alg type to
                 * NIX_SENDMEMALG_SET and also changing send mem addr field to
                 * next 8 bytes as it corrpt the actual tx tstamp registered
@@ -152,12 +152,12 @@ otx2_nix_xmit_prepare_tso(struct rte_mbuf *m, const uint64_t flags)
        uint64_t mask, ol_flags = m->ol_flags;
 
        if (flags & NIX_TX_OFFLOAD_TSO_F &&
-           (ol_flags & PKT_TX_TCP_SEG)) {
+           (ol_flags & RTE_MBUF_F_TX_TCP_SEG)) {
                uintptr_t mdata = rte_pktmbuf_mtod(m, uintptr_t);
                uint16_t *iplen, *oiplen, *oudplen;
                uint16_t lso_sb, paylen;
 
-               mask = -!!(ol_flags & (PKT_TX_OUTER_IPV4 | PKT_TX_OUTER_IPV6));
+               mask = -!!(ol_flags & (RTE_MBUF_F_TX_OUTER_IPV4 | RTE_MBUF_F_TX_OUTER_IPV6));
                lso_sb = (mask & (m->outer_l2_len + m->outer_l3_len)) +
                        m->l2_len + m->l3_len + m->l4_len;
 
@@ -166,15 +166,15 @@ otx2_nix_xmit_prepare_tso(struct rte_mbuf *m, const uint64_t flags)
 
                /* Get iplen position assuming no tunnel hdr */
                iplen = (uint16_t *)(mdata + m->l2_len +
-                                    (2 << !!(ol_flags & PKT_TX_IPV6)));
+                                    (2 << !!(ol_flags & RTE_MBUF_F_TX_IPV6)));
                /* Handle tunnel tso */
                if ((flags & NIX_TX_OFFLOAD_OL3_OL4_CSUM_F) &&
-                   (ol_flags & PKT_TX_TUNNEL_MASK)) {
+                   (ol_flags & RTE_MBUF_F_TX_TUNNEL_MASK)) {
                        const uint8_t is_udp_tun = (NIX_UDP_TUN_BITMASK >>
-                               ((ol_flags & PKT_TX_TUNNEL_MASK) >> 45)) & 0x1;
+                               ((ol_flags & RTE_MBUF_F_TX_TUNNEL_MASK) >> 45)) & 0x1;
 
                        oiplen = (uint16_t *)(mdata + m->outer_l2_len +
-                               (2 << !!(ol_flags & PKT_TX_OUTER_IPV6)));
+                               (2 << !!(ol_flags & RTE_MBUF_F_TX_OUTER_IPV6)));
                        *oiplen = rte_cpu_to_be_16(rte_be_to_cpu_16(*oiplen) -
                                                   paylen);
 
@@ -189,7 +189,7 @@ otx2_nix_xmit_prepare_tso(struct rte_mbuf *m, const uint64_t flags)
 
                        /* Update iplen position to inner ip hdr */
                        iplen = (uint16_t *)(mdata + lso_sb - m->l3_len -
-                               m->l4_len + (2 << !!(ol_flags & PKT_TX_IPV6)));
+                               m->l4_len + (2 << !!(ol_flags & RTE_MBUF_F_TX_IPV6)));
                }
 
                *iplen = rte_cpu_to_be_16(rte_be_to_cpu_16(*iplen) - paylen);
@@ -239,11 +239,11 @@ otx2_nix_xmit_prepare(struct rte_mbuf *m, uint64_t *cmd, const uint16_t flags,
 
        if ((flags & NIX_TX_OFFLOAD_OL3_OL4_CSUM_F) &&
            (flags & NIX_TX_OFFLOAD_L3_L4_CSUM_F)) {
-               const uint8_t csum = !!(ol_flags & PKT_TX_OUTER_UDP_CKSUM);
+               const uint8_t csum = !!(ol_flags & RTE_MBUF_F_TX_OUTER_UDP_CKSUM);
                const uint8_t ol3type =
-                       ((!!(ol_flags & PKT_TX_OUTER_IPV4)) << 1) +
-                       ((!!(ol_flags & PKT_TX_OUTER_IPV6)) << 2) +
-                       !!(ol_flags & PKT_TX_OUTER_IP_CKSUM);
+                       ((!!(ol_flags & RTE_MBUF_F_TX_OUTER_IPV4)) << 1) +
+                       ((!!(ol_flags & RTE_MBUF_F_TX_OUTER_IPV6)) << 2) +
+                       !!(ol_flags & RTE_MBUF_F_TX_OUTER_IP_CKSUM);
 
                /* Outer L3 */
                w1.ol3type = ol3type;
@@ -255,15 +255,15 @@ otx2_nix_xmit_prepare(struct rte_mbuf *m, uint64_t *cmd, const uint16_t flags,
                w1.ol4type = csum + (csum << 1);
 
                /* Inner L3 */
-               w1.il3type = ((!!(ol_flags & PKT_TX_IPV4)) << 1) +
-                       ((!!(ol_flags & PKT_TX_IPV6)) << 2);
+               w1.il3type = ((!!(ol_flags & RTE_MBUF_F_TX_IPV4)) << 1) +
+                       ((!!(ol_flags & RTE_MBUF_F_TX_IPV6)) << 2);
                w1.il3ptr = w1.ol4ptr + m->l2_len;
                w1.il4ptr = w1.il3ptr + m->l3_len;
                /* Increment it by 1 if it is IPV4 as 3 is with csum */
-               w1.il3type = w1.il3type + !!(ol_flags & PKT_TX_IP_CKSUM);
+               w1.il3type = w1.il3type + !!(ol_flags & RTE_MBUF_F_TX_IP_CKSUM);
 
                /* Inner L4 */
-               w1.il4type =  (ol_flags & PKT_TX_L4_MASK) >> 52;
+               w1.il4type =  (ol_flags & RTE_MBUF_F_TX_L4_MASK) >> 52;
 
                /* In case of no tunnel header use only
                 * shift IL3/IL4 fields a bit to use
@@ -274,16 +274,16 @@ otx2_nix_xmit_prepare(struct rte_mbuf *m, uint64_t *cmd, const uint16_t flags,
                        ((w1.u & 0X00000000FFFFFFFF) >> (mask << 4));
 
        } else if (flags & NIX_TX_OFFLOAD_OL3_OL4_CSUM_F) {
-               const uint8_t csum = !!(ol_flags & PKT_TX_OUTER_UDP_CKSUM);
+               const uint8_t csum = !!(ol_flags & RTE_MBUF_F_TX_OUTER_UDP_CKSUM);
                const uint8_t outer_l2_len = m->outer_l2_len;
 
                /* Outer L3 */
                w1.ol3ptr = outer_l2_len;
                w1.ol4ptr = outer_l2_len + m->outer_l3_len;
                /* Increment it by 1 if it is IPV4 as 3 is with csum */
-               w1.ol3type = ((!!(ol_flags & PKT_TX_OUTER_IPV4)) << 1) +
-                       ((!!(ol_flags & PKT_TX_OUTER_IPV6)) << 2) +
-                       !!(ol_flags & PKT_TX_OUTER_IP_CKSUM);
+               w1.ol3type = ((!!(ol_flags & RTE_MBUF_F_TX_OUTER_IPV4)) << 1) +
+                       ((!!(ol_flags & RTE_MBUF_F_TX_OUTER_IPV6)) << 2) +
+                       !!(ol_flags & RTE_MBUF_F_TX_OUTER_IP_CKSUM);
 
                /* Outer L4 */
                w1.ol4type = csum + (csum << 1);
@@ -299,29 +299,29 @@ otx2_nix_xmit_prepare(struct rte_mbuf *m, uint64_t *cmd, const uint16_t flags,
                w1.ol3ptr = l2_len;
                w1.ol4ptr = l2_len + m->l3_len;
                /* Increment it by 1 if it is IPV4 as 3 is with csum */
-               w1.ol3type = ((!!(ol_flags & PKT_TX_IPV4)) << 1) +
-                       ((!!(ol_flags & PKT_TX_IPV6)) << 2) +
-                       !!(ol_flags & PKT_TX_IP_CKSUM);
+               w1.ol3type = ((!!(ol_flags & RTE_MBUF_F_TX_IPV4)) << 1) +
+                       ((!!(ol_flags & RTE_MBUF_F_TX_IPV6)) << 2) +
+                       !!(ol_flags & RTE_MBUF_F_TX_IP_CKSUM);
 
                /* Inner L4 */
-               w1.ol4type =  (ol_flags & PKT_TX_L4_MASK) >> 52;
+               w1.ol4type =  (ol_flags & RTE_MBUF_F_TX_L4_MASK) >> 52;
        }
 
        if (flags & NIX_TX_NEED_EXT_HDR &&
            flags & NIX_TX_OFFLOAD_VLAN_QINQ_F) {
-               send_hdr_ext->w1.vlan1_ins_ena = !!(ol_flags & PKT_TX_VLAN);
+               send_hdr_ext->w1.vlan1_ins_ena = !!(ol_flags & RTE_MBUF_F_TX_VLAN);
                /* HW will update ptr after vlan0 update */
                send_hdr_ext->w1.vlan1_ins_ptr = 12;
                send_hdr_ext->w1.vlan1_ins_tci = m->vlan_tci;
 
-               send_hdr_ext->w1.vlan0_ins_ena = !!(ol_flags & PKT_TX_QINQ);
+               send_hdr_ext->w1.vlan0_ins_ena = !!(ol_flags & RTE_MBUF_F_TX_QINQ);
                /* 2B before end of l2 header */
                send_hdr_ext->w1.vlan0_ins_ptr = 12;
                send_hdr_ext->w1.vlan0_ins_tci = m->vlan_tci_outer;
        }
 
        if (flags & NIX_TX_OFFLOAD_TSO_F &&
-           (ol_flags & PKT_TX_TCP_SEG)) {
+           (ol_flags & RTE_MBUF_F_TX_TCP_SEG)) {
                uint16_t lso_sb;
                uint64_t mask;
 
@@ -332,18 +332,18 @@ otx2_nix_xmit_prepare(struct rte_mbuf *m, uint64_t *cmd, const uint16_t flags,
                send_hdr_ext->w0.lso = 1;
                send_hdr_ext->w0.lso_mps = m->tso_segsz;
                send_hdr_ext->w0.lso_format =
-                       NIX_LSO_FORMAT_IDX_TSOV4 + !!(ol_flags & PKT_TX_IPV6);
+                       NIX_LSO_FORMAT_IDX_TSOV4 + !!(ol_flags & RTE_MBUF_F_TX_IPV6);
                w1.ol4type = NIX_SENDL4TYPE_TCP_CKSUM;
 
                /* Handle tunnel tso */
                if ((flags & NIX_TX_OFFLOAD_OL3_OL4_CSUM_F) &&
-                   (ol_flags & PKT_TX_TUNNEL_MASK)) {
+                   (ol_flags & RTE_MBUF_F_TX_TUNNEL_MASK)) {
                        const uint8_t is_udp_tun = (NIX_UDP_TUN_BITMASK >>
-                               ((ol_flags & PKT_TX_TUNNEL_MASK) >> 45)) & 0x1;
+                               ((ol_flags & RTE_MBUF_F_TX_TUNNEL_MASK) >> 45)) & 0x1;
                        uint8_t shift = is_udp_tun ? 32 : 0;
 
-                       shift += (!!(ol_flags & PKT_TX_OUTER_IPV6) << 4);
-                       shift += (!!(ol_flags & PKT_TX_IPV6) << 3);
+                       shift += (!!(ol_flags & RTE_MBUF_F_TX_OUTER_IPV6) << 4);
+                       shift += (!!(ol_flags & RTE_MBUF_F_TX_IPV6) << 3);
 
                        w1.il4type = NIX_SENDL4TYPE_TCP_CKSUM;
                        w1.ol4type = is_udp_tun ? NIX_SENDL4TYPE_UDP_CKSUM : 0;