net/ice/base: support GTP and PPPoE protocols

Added switch protocol segments for both GTP and PPPOE protocols.
Added RSS protocol segments for both GTP and PPPOE protocols.

Signed-off-by: Dan Nowlin <dan.nowlin@intel.com>
Signed-off-by: Paul M Stillwell Jr <paul.m.stillwell.jr@intel.com>
Signed-off-by: Qi Zhang <qi.z.zhang@intel.com>
Acked-by: Xiaolong Ye <xiaolong.ye@intel.com>

diff --git a/drivers/net/ice/base/ice_flow.c b/drivers/net/ice/base/ice_flow.c
index 1530a72..0f52b33 100644 (file)
--- a/drivers/net/ice/base/ice_flow.c
+++ b/drivers/net/ice/base/ice_flow.c
@@ -19,6 +19,8 @@
 #define ICE_FLOW_FLD_SZ_ICMP_CODE      1
 #define ICE_FLOW_FLD_SZ_ARP_OPER       2
 #define ICE_FLOW_FLD_SZ_GRE_KEYID      4
+#define ICE_FLOW_FLD_SZ_GTP_TEID       4
+#define ICE_FLOW_FLD_SZ_PPPOE_SESS_ID   2
 
 /* Protocol header fields are extracted at the word boundaries as word-sized
  * values. Specify the displacement value of some non-word-aligned fields needed
@@ -115,6 +117,23 @@ struct ice_flow_field_info ice_flds_info[ICE_FLOW_FIELD_IDX_MAX] = {
        /* GRE */
        /* ICE_FLOW_FIELD_IDX_GRE_KEYID */
        ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_GRE, 12, ICE_FLOW_FLD_SZ_GRE_KEYID),
+       /* GTP */
+       /* ICE_FLOW_FIELD_IDX_GTPC_TEID */
+       ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_GTPC_TEID, 12,
+                         ICE_FLOW_FLD_SZ_GTP_TEID),
+       /* ICE_FLOW_FIELD_IDX_GTPU_IP_TEID */
+       ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_GTPU_IP, 12,
+                         ICE_FLOW_FLD_SZ_GTP_TEID),
+       /* ICE_FLOW_FIELD_IDX_GTPU_UP_TEID */
+       ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_GTPU_UP, 12,
+                         ICE_FLOW_FLD_SZ_GTP_TEID),
+       /* ICE_FLOW_FIELD_IDX_GTPU_DWN_TEID */
+       ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_GTPU_DWN, 12,
+                         ICE_FLOW_FLD_SZ_GTP_TEID),
+       /* PPPOE */
+       /* ICE_FLOW_FIELD_IDX_PPPOE_SESS_ID */
+       ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_PPPOE, 2,
+                         ICE_FLOW_FLD_SZ_PPPOE_SESS_ID),
 };
 
 /* Bitmaps indicating relevant packet types for a particular protocol header
@@ -290,6 +309,42 @@ static const u32 ice_ptypes_mac_il[] = {
        0x00000000, 0x00000000, 0x00000000, 0x00000000,
 };
 
+/* Packet types for GTPC */
+static const u32 ice_ptypes_gtpc[] = {
+       0x00000000, 0x00000000, 0x00000000, 0x00000000,
+       0x00000000, 0x00000000, 0x00000000, 0x00000000,
+       0x00000000, 0x00000000, 0x00000180, 0x00000000,
+       0x00000000, 0x00000000, 0x00000000, 0x00000000,
+       0x00000000, 0x00000000, 0x00000000, 0x00000000,
+       0x00000000, 0x00000000, 0x00000000, 0x00000000,
+       0x00000000, 0x00000000, 0x00000000, 0x00000000,
+       0x00000000, 0x00000000, 0x00000000, 0x00000000,
+};
+
+/* Packet types for GTPC with TEID */
+static const u32 ice_ptypes_gtpc_tid[] = {
+       0x00000000, 0x00000000, 0x00000000, 0x00000000,
+       0x00000000, 0x00000000, 0x00000000, 0x00000000,
+       0x00000000, 0x00000000, 0x00000060, 0x00000000,
+       0x00000000, 0x00000000, 0x00000000, 0x00000000,
+       0x00000000, 0x00000000, 0x00000000, 0x00000000,
+       0x00000000, 0x00000000, 0x00000000, 0x00000000,
+       0x00000000, 0x00000000, 0x00000000, 0x00000000,
+       0x00000000, 0x00000000, 0x00000000, 0x00000000,
+};
+
+/* Packet types for GTPU */
+static const u32 ice_ptypes_gtpu[] = {
+       0x00000000, 0x00000000, 0x00000000, 0x00000000,
+       0x00000000, 0x00000000, 0x00000000, 0x00000000,
+       0x00000000, 0x00000000, 0x7FFFF800, 0x00000000,
+       0x00000000, 0x00000000, 0x00000000, 0x00000000,
+       0x00000000, 0x00000000, 0x00000000, 0x00000000,
+       0x00000000, 0x00000000, 0x00000000, 0x00000000,
+       0x00000000, 0x00000000, 0x00000000, 0x00000000,
+       0x00000000, 0x00000000, 0x00000000, 0x00000000,
+};
+
 /* Manage parameters and info. used during the creation of a flow profile */
 struct ice_flow_prof_params {
        enum ice_block blk;
@@ -317,10 +372,13 @@ static bool ice_is_pow2(u64 val)
 #define ICE_FLOW_SEG_HDRS_L2_MASK      \
        (ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_VLAN)
 #define ICE_FLOW_SEG_HDRS_L3_MASK      \
-       (ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_ARP)
+       (ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV6 | \
+        ICE_FLOW_SEG_HDR_ARP | ICE_FLOW_SEG_HDR_PPPOE)
 #define ICE_FLOW_SEG_HDRS_L4_MASK      \
        (ICE_FLOW_SEG_HDR_ICMP | ICE_FLOW_SEG_HDR_TCP | ICE_FLOW_SEG_HDR_UDP | \
-        ICE_FLOW_SEG_HDR_SCTP)
+        ICE_FLOW_SEG_HDR_SCTP | ICE_FLOW_SEG_HDR_GTPC | \
+        ICE_FLOW_SEG_HDR_GTPC_TEID | ICE_FLOW_SEG_HDR_GTPU_IP | \
+        ICE_FLOW_SEG_HDR_GTPU_UP | ICE_FLOW_SEG_HDR_GTPU_DWN)
 
 /**
  * ice_flow_val_hdrs - validates packet segments for valid protocol headers
@@ -431,21 +489,18 @@ ice_flow_proc_seg_hdrs(struct ice_flow_prof_params *params)
                                (const ice_bitmap_t *)ice_ptypes_mac_il;
                        ice_and_bitmap(params->ptypes, params->ptypes, src,
                                       ICE_FLOW_PTYPE_MAX);
-                       hdrs &= ~ICE_FLOW_SEG_HDR_ETH;
                }
 
                if (i && hdrs & ICE_FLOW_SEG_HDR_VLAN) {
                        src = (const ice_bitmap_t *)ice_ptypes_macvlan_il;
                        ice_and_bitmap(params->ptypes, params->ptypes, src,
                                       ICE_FLOW_PTYPE_MAX);
-                       hdrs &= ~ICE_FLOW_SEG_HDR_VLAN;
                }
 
                if (!i && hdrs & ICE_FLOW_SEG_HDR_ARP) {
                        ice_and_bitmap(params->ptypes, params->ptypes,
                                       (const ice_bitmap_t *)ice_ptypes_arp_of,
                                       ICE_FLOW_PTYPE_MAX);
-                       hdrs &= ~ICE_FLOW_SEG_HDR_ARP;
                }
 
                if (hdrs & ICE_FLOW_SEG_HDR_IPV4) {
@@ -453,13 +508,11 @@ ice_flow_proc_seg_hdrs(struct ice_flow_prof_params *params)
                                (const ice_bitmap_t *)ice_ptypes_ipv4_il;
                        ice_and_bitmap(params->ptypes, params->ptypes, src,
                                       ICE_FLOW_PTYPE_MAX);
-                       hdrs &= ~ICE_FLOW_SEG_HDR_IPV4;
                } else if (hdrs & ICE_FLOW_SEG_HDR_IPV6) {
                        src = !i ? (const ice_bitmap_t *)ice_ptypes_ipv6_ofos :
                                (const ice_bitmap_t *)ice_ptypes_ipv6_il;
                        ice_and_bitmap(params->ptypes, params->ptypes, src,
                                       ICE_FLOW_PTYPE_MAX);
-                       hdrs &= ~ICE_FLOW_SEG_HDR_IPV6;
                }
 
                if (hdrs & ICE_FLOW_SEG_HDR_ICMP) {
@@ -467,29 +520,42 @@ ice_flow_proc_seg_hdrs(struct ice_flow_prof_params *params)
                                (const ice_bitmap_t *)ice_ptypes_icmp_il;
                        ice_and_bitmap(params->ptypes, params->ptypes, src,
                                       ICE_FLOW_PTYPE_MAX);
-                       hdrs &= ~ICE_FLOW_SEG_HDR_ICMP;
                } else if (hdrs & ICE_FLOW_SEG_HDR_UDP) {
                        src = (const ice_bitmap_t *)ice_ptypes_udp_il;
                        ice_and_bitmap(params->ptypes, params->ptypes, src,
                                       ICE_FLOW_PTYPE_MAX);
-                       hdrs &= ~ICE_FLOW_SEG_HDR_UDP;
                } else if (hdrs & ICE_FLOW_SEG_HDR_TCP) {
                        ice_and_bitmap(params->ptypes, params->ptypes,
                                       (const ice_bitmap_t *)ice_ptypes_tcp_il,
                                       ICE_FLOW_PTYPE_MAX);
-                       hdrs &= ~ICE_FLOW_SEG_HDR_TCP;
                } else if (hdrs & ICE_FLOW_SEG_HDR_SCTP) {
                        src = (const ice_bitmap_t *)ice_ptypes_sctp_il;
                        ice_and_bitmap(params->ptypes, params->ptypes, src,
                                       ICE_FLOW_PTYPE_MAX);
-                       hdrs &= ~ICE_FLOW_SEG_HDR_SCTP;
                } else if (hdrs & ICE_FLOW_SEG_HDR_GRE) {
                        if (!i) {
                                src = (const ice_bitmap_t *)ice_ptypes_gre_of;
                                ice_and_bitmap(params->ptypes, params->ptypes,
                                               src, ICE_FLOW_PTYPE_MAX);
                        }
-                       hdrs &= ~ICE_FLOW_SEG_HDR_GRE;
+               } else if (hdrs & ICE_FLOW_SEG_HDR_GTPC) {
+                       if (!i) {
+                               src = (const ice_bitmap_t *)ice_ptypes_gtpc;
+                               ice_and_bitmap(params->ptypes, params->ptypes,
+                                              src, ICE_FLOW_PTYPE_MAX);
+                       }
+               } else if (hdrs & ICE_FLOW_SEG_HDR_GTPC_TEID) {
+                       if (!i) {
+                               src = (const ice_bitmap_t *)ice_ptypes_gtpc_tid;
+                               ice_and_bitmap(params->ptypes, params->ptypes,
+                                              src, ICE_FLOW_PTYPE_MAX);
+                       }
+               } else if (hdrs & ICE_FLOW_SEG_HDR_GTPU) {
+                       if (!i) {
+                               src = (const ice_bitmap_t *)ice_ptypes_gtpu;
+                               ice_and_bitmap(params->ptypes, params->ptypes,
+                                              src, ICE_FLOW_PTYPE_MAX);
+                       }
                }
        }
 
@@ -619,6 +685,16 @@ ice_flow_xtract_fld(struct ice_hw *hw, struct ice_flow_prof_params *params,
        case ICE_FLOW_FIELD_IDX_SCTP_DST_PORT:
                prot_id = ICE_PROT_SCTP_IL;
                break;
+       case ICE_FLOW_FIELD_IDX_GTPC_TEID:
+       case ICE_FLOW_FIELD_IDX_GTPU_IP_TEID:
+       case ICE_FLOW_FIELD_IDX_GTPU_UP_TEID:
+       case ICE_FLOW_FIELD_IDX_GTPU_DWN_TEID:
+               /* GTP is accessed through UDP OF protocol */
+               prot_id = ICE_PROT_UDP_OF;
+               break;
+       case ICE_FLOW_FIELD_IDX_PPPOE_SESS_ID:
+               prot_id = ICE_PROT_PPPOE;
+               break;
        case ICE_FLOW_FIELD_IDX_ARP_SIP:
        case ICE_FLOW_FIELD_IDX_ARP_DIP:
        case ICE_FLOW_FIELD_IDX_ARP_SHA:
@@ -1601,11 +1677,12 @@ ice_flow_add_fld_raw(struct ice_flow_seg_info *seg, u16 off, u8 len,
 }
 
 #define ICE_FLOW_RSS_SEG_HDR_L3_MASKS \
-       (ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV6)
+       (ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_PPPOE)
 
 #define ICE_FLOW_RSS_SEG_HDR_L4_MASKS \
        (ICE_FLOW_SEG_HDR_TCP | ICE_FLOW_SEG_HDR_UDP | \
-        ICE_FLOW_SEG_HDR_SCTP)
+        ICE_FLOW_SEG_HDR_SCTP | ICE_FLOW_SEG_HDR_GTPC_TEID)
+
 
 #define ICE_FLOW_RSS_SEG_HDR_VAL_MASKS \
        (ICE_FLOW_RSS_SEG_HDR_L3_MASKS | \

diff --git a/drivers/net/ice/base/ice_flow.h b/drivers/net/ice/base/ice_flow.h
index 3a0fd23..eb8e1b7 100644 (file)
--- a/drivers/net/ice/base/ice_flow.h
+++ b/drivers/net/ice/base/ice_flow.h
@@ -41,6 +41,17 @@
 #define ICE_HASH_SCTP_IPV4     (ICE_FLOW_HASH_IPV4 | ICE_FLOW_HASH_SCTP_PORT)
 #define ICE_HASH_SCTP_IPV6     (ICE_FLOW_HASH_IPV6 | ICE_FLOW_HASH_SCTP_PORT)
 
+#define ICE_FLOW_HASH_GTP_TEID \
+       (ICE_FLOW_HASH_FLD(ICE_FLOW_FIELD_IDX_GTPC_TEID))
+
+#define ICE_FLOW_HASH_GTP_IPV4_TEID \
+       (ICE_FLOW_HASH_IPV4 | ICE_FLOW_HASH_GTP_TEID)
+#define ICE_FLOW_HASH_GTP_IPV6_TEID \
+       (ICE_FLOW_HASH_IPV6 | ICE_FLOW_HASH_GTP_TEID)
+
+#define ICE_FLOW_HASH_PPPOE_SESS_ID \
+       (ICE_FLOW_HASH_FLD(ICE_FLOW_FIELD_IDX_PPPOE_SESS_ID))
+
 /* Protocol header fields within a packet segment. A segment consists of one or
  * more protocol headers that make up a logical group of protocol headers. Each
  * logical group of protocol headers encapsulates or is encapsulated using/by
@@ -48,19 +59,37 @@
  * VxLAN, etc.
  */
 enum ice_flow_seg_hdr {
-       ICE_FLOW_SEG_HDR_NONE   = 0x00000000,
-       ICE_FLOW_SEG_HDR_ETH    = 0x00000001,
-       ICE_FLOW_SEG_HDR_VLAN   = 0x00000002,
-       ICE_FLOW_SEG_HDR_IPV4   = 0x00000004,
-       ICE_FLOW_SEG_HDR_IPV6   = 0x00000008,
-       ICE_FLOW_SEG_HDR_ARP    = 0x00000010,
-       ICE_FLOW_SEG_HDR_ICMP   = 0x00000020,
-       ICE_FLOW_SEG_HDR_TCP    = 0x00000040,
-       ICE_FLOW_SEG_HDR_UDP    = 0x00000080,
-       ICE_FLOW_SEG_HDR_SCTP   = 0x00000100,
-       ICE_FLOW_SEG_HDR_GRE    = 0x00000200,
+       ICE_FLOW_SEG_HDR_NONE           = 0x00000000,
+       ICE_FLOW_SEG_HDR_ETH            = 0x00000001,
+       ICE_FLOW_SEG_HDR_VLAN           = 0x00000002,
+       ICE_FLOW_SEG_HDR_IPV4           = 0x00000004,
+       ICE_FLOW_SEG_HDR_IPV6           = 0x00000008,
+       ICE_FLOW_SEG_HDR_ARP            = 0x00000010,
+       ICE_FLOW_SEG_HDR_ICMP           = 0x00000020,
+       ICE_FLOW_SEG_HDR_TCP            = 0x00000040,
+       ICE_FLOW_SEG_HDR_UDP            = 0x00000080,
+       ICE_FLOW_SEG_HDR_SCTP           = 0x00000100,
+       ICE_FLOW_SEG_HDR_GRE            = 0x00000200,
+       ICE_FLOW_SEG_HDR_GTPC           = 0x00000400,
+       ICE_FLOW_SEG_HDR_GTPC_TEID      = 0x00000800,
+       ICE_FLOW_SEG_HDR_GTPU_IP        = 0x00001000,
+       ICE_FLOW_SEG_HDR_GTPU_DWN       = 0x00002000,
+       ICE_FLOW_SEG_HDR_GTPU_UP        = 0x00004000,
+       ICE_FLOW_SEG_HDR_PPPOE          = 0x00008000,
 };
 
+/* These segements all have the same PTYPES, but are otherwise distinguished by
+ * the value of the gtp_eh_pdu and gtp_eh_pdu_link flags:
+ *
+ *                                gtp_eh_pdu     gtp_eh_pdu_link
+ * ICE_FLOW_SEG_HDR_GTPU_IP           0              0
+ * ICE_FLOW_SEG_HDR_GTPU_DWN          1              0
+ * ICE_FLOW_SEG_HDR_GTPU_UP           1              1
+ */
+#define ICE_FLOW_SEG_HDR_GTPU (ICE_FLOW_SEG_HDR_GTPU_IP | \
+                              ICE_FLOW_SEG_HDR_GTPU_DWN | \
+                              ICE_FLOW_SEG_HDR_GTPU_UP)
+
 enum ice_flow_field {
        /* L2 */
        ICE_FLOW_FIELD_IDX_ETH_DA,
@@ -95,6 +124,16 @@ enum ice_flow_field {
        ICE_FLOW_FIELD_IDX_ICMP_CODE,
        /* GRE */
        ICE_FLOW_FIELD_IDX_GRE_KEYID,
+       /* GTPC_TEID */
+       ICE_FLOW_FIELD_IDX_GTPC_TEID,
+       /* GTPU_IP */
+       ICE_FLOW_FIELD_IDX_GTPU_IP_TEID,
+       /* GTPU_UP */
+       ICE_FLOW_FIELD_IDX_GTPU_UP_TEID,
+       /* GTPU_DWN */
+       ICE_FLOW_FIELD_IDX_GTPU_DWN_TEID,
+       /* PPPOE */
+       ICE_FLOW_FIELD_IDX_PPPOE_SESS_ID,
         /* The total number of enums must not exceed 64 */
        ICE_FLOW_FIELD_IDX_MAX
 };

diff --git a/drivers/net/ice/base/ice_protocol_type.h b/drivers/net/ice/base/ice_protocol_type.h
index cfbe3fb..29375d3 100644 (file)
--- a/drivers/net/ice/base/ice_protocol_type.h
+++ b/drivers/net/ice/base/ice_protocol_type.h
@@ -43,6 +43,8 @@ enum ice_protocol_type {
        ICE_GENEVE,
        ICE_VXLAN_GPE,
        ICE_NVGRE,
+       ICE_GTP,
+       ICE_PPPOE,
        ICE_PROTOCOL_LAST
 };
 
@@ -55,6 +57,8 @@ enum ice_sw_tunnel_type {
        ICE_SW_TUN_UDP, /* This means all "UDP" tunnel types: VXLAN-GPE, VXLAN
                         * and GENEVE
                         */
+       ICE_SW_TUN_GTP,
+       ICE_SW_TUN_PPPOE,
        ICE_ALL_TUNNELS /* All tunnel types including NVGRE */
 };
 
@@ -97,6 +101,7 @@ enum ice_prot_id {
        ICE_PROT_ICMPV6_IL      = 100,
        ICE_PROT_VRRP_F         = 101,
        ICE_PROT_OSPF           = 102,
+       ICE_PROT_PPPOE          = 103,
        ICE_PROT_ATAOE_OF       = 114,
        ICE_PROT_CTRL_OF        = 116,
        ICE_PROT_LLDP_OF        = 117,
@@ -115,9 +120,9 @@ enum ice_prot_id {
 #define ICE_IPV6_OFOS_HW       40
 #define ICE_IPV6_IL_HW         41
 #define ICE_TCP_IL_HW          49
-#define ICE_UDP_OF_HW          52
 #define ICE_UDP_ILOS_HW                53
 #define ICE_SCTP_IL_HW         96
+#define ICE_PPPOE_HW           103
 
 /* ICE_UDP_OF is used to identify all 3 tunnel types
  * VXLAN, GENEVE and VXLAN_GPE. To differentiate further
@@ -198,6 +203,30 @@ struct ice_udp_tnl_hdr {
        u32 vni;        /* only use lower 24-bits */
 };
 
+#pragma pack(1)
+struct ice_udp_gtp_hdr {
+       u8 flags;
+       u8 msg_type;
+       u16 rsrvd_len;
+       u32 teid;
+       u16 rsrvd_seq_nbr;
+       u8 rsrvd_n_pdu_nbr;
+       u8 rsrvd_next_ext;
+       u8 rsvrd_ext_len;
+       u8 pdu_type;
+       u8 qfi;
+       u8 rsvrd;
+};
+
+struct ice_pppoe_hdr {
+       u8 rsrvd_ver_type;
+       u8 rsrved_code;
+       u16 session_id;
+       u16 length;
+       u16 ppp_prot_id; /* control and data only */
+};
+#pragma pack()
+
 struct ice_nvgre {
        u16 flags;
        u16 protocol;
@@ -213,6 +242,8 @@ union ice_prot_hdr {
        struct ice_sctp_hdr sctp_hdr;
        struct ice_udp_tnl_hdr tnl_hdr;
        struct ice_nvgre nvgre_hdr;
+       struct ice_udp_gtp_hdr gtp_hdr;
+       struct ice_pppoe_hdr pppoe_hdr;
 };
 
 /* This is mapping table entry that maps every word within a given protocol

diff --git a/drivers/net/ice/base/ice_switch.c b/drivers/net/ice/base/ice_switch.c
index b249a30..f88adde 100644 (file)
--- a/drivers/net/ice/base/ice_switch.c
+++ b/drivers/net/ice/base/ice_switch.c
@@ -380,7 +380,64 @@ dummy_udp_ipv6_packet[] = {
        0x00, 0x00, /* 2 bytes for 4 byte alignment */
 };
 
-/* this is a recipe to profile bitmap association */
+static const
+struct ice_dummy_pkt_offsets dummy_udp_gtp_packet_offsets[] = {
+       { ICE_MAC_OFOS,         0 },
+       { ICE_IPV4_OFOS,        14 },
+       { ICE_UDP_OF,           34 },
+       { ICE_GTP,              42 },
+       { ICE_PROTOCOL_LAST,    0 },
+};
+
+static const u8
+dummy_udp_gtp_packet[] = {
+       0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */
+       0x00, 0x00, 0x00, 0x00,
+       0x00, 0x00, 0x00, 0x00,
+       0x08, 0x00,
+
+       0x45, 0x00, 0x00, 0x30, /* ICE_IPV4_OFOS 14 */
+       0x00, 0x00, 0x00, 0x00,
+       0x00, 0x11, 0x00, 0x00,
+       0x00, 0x00, 0x00, 0x00,
+       0x00, 0x00, 0x00, 0x00,
+
+       0x00, 0x00, 0x08, 0x68, /* ICE_UDP_OF 34 */
+       0x00, 0x1c, 0x00, 0x00,
+
+       0x34, 0xff, 0x00, 0x0c, /* ICE_GTP 42 */
+       0x00, 0x00, 0x00, 0x00,
+       0x00, 0x00, 0x00, 0x85,
+
+       0x02, 0x00, 0x00, 0x00, /* PDU Session extension header */
+       0x00, 0x00, 0x00, 0x00,
+};
+
+static const
+struct ice_dummy_pkt_offsets dummy_pppoe_packet_offsets[] = {
+       { ICE_MAC_OFOS,                 0 },
+       { ICE_PPPOE,                    14 },
+       { ICE_PROTOCOL_LAST,    0 },
+};
+
+static const u8
+dummy_pppoe_packet[] = {
+       0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */
+       0x00, 0x00, 0x00, 0x00,
+       0x00, 0x00, 0x00, 0x00,
+       0x88, 0x64,
+
+       0x11, 0x00, 0x00, 0x01, /* ICE_PPPOE 14 */
+       0x00, 0x4e, 0x00, 0x21,
+
+       0x45, 0x00, 0x00, 0x30, /* PDU */
+       0x00, 0x00, 0x00, 0x00,
+       0x00, 0x11, 0x00, 0x00,
+       0x00, 0x00, 0x00, 0x00,
+       0x00, 0x00, 0x00, 0x00,
+};
+
+/* this is a recipe to profile association bitmap */
 static ice_declare_bitmap(recipe_to_profile[ICE_MAX_NUM_RECIPES],
                          ICE_MAX_NUM_PROFILES);
 static ice_declare_bitmap(available_result_ids, ICE_CHAIN_FV_INDEX_START + 1);
@@ -4541,6 +4598,8 @@ static const struct ice_prot_ext_tbl_entry ice_prot_ext[] = {
        { ICE_GENEVE,           { 8, 10, 12, 14 } },
        { ICE_VXLAN_GPE,        { 0, 2, 4 } },
        { ICE_NVGRE,            { 0, 2, 4, 6 } },
+       { ICE_GTP,              { 8, 10, 12, 14, 16, 18, 20 } },
+       { ICE_PPPOE,            { 0, 2, 4, 6 } },
        { ICE_PROTOCOL_LAST,    { 0 } }
 };
 
@@ -4577,6 +4636,8 @@ static const struct ice_protocol_entry ice_prot_id_tbl[] = {
        { ICE_GENEVE,           ICE_UDP_OF_HW },
        { ICE_VXLAN_GPE,        ICE_UDP_OF_HW },
        { ICE_NVGRE,            ICE_GRE_OF_HW },
+       { ICE_GTP,              ICE_UDP_OF_HW },
+       { ICE_PPPOE,            ICE_PPPOE_HW },
        { ICE_PROTOCOL_LAST,    0 }
 };
 
@@ -5418,6 +5479,18 @@ ice_find_dummy_packet(struct ice_adv_lkup_elem *lkups, u16 lkups_cnt,
        bool tcp = false, udp = false, ipv6 = false;
        u16 i;
 
+       if (tun_type == ICE_SW_TUN_GTP) {
+               *pkt = dummy_udp_gtp_packet;
+               *pkt_len = sizeof(dummy_udp_gtp_packet);
+               *offsets = dummy_udp_gtp_packet_offsets;
+               return;
+       }
+       if (tun_type == ICE_SW_TUN_PPPOE) {
+               *pkt = dummy_pppoe_packet;
+               *pkt_len = sizeof(dummy_pppoe_packet);
+               *offsets = dummy_pppoe_packet_offsets;
+               return;
+       }
        for (i = 0; i < lkups_cnt; i++) {
                if (lkups[i].type == ICE_UDP_ILOS)
                        udp = true;
@@ -5564,6 +5637,10 @@ ice_fill_adv_dummy_packet(struct ice_adv_lkup_elem *lkups, u16 lkups_cnt,
                case ICE_VXLAN_GPE:
                        len = sizeof(struct ice_udp_tnl_hdr);
                        break;
+
+               case ICE_GTP:
+                       len = sizeof(struct ice_udp_gtp_hdr);
+                       break;
                default:
                        return ICE_ERR_PARAM;
                }