net/ice: support switch flow for specific L4 type
[dpdk.git] / drivers / net / ice / ice_switch_filter.c
index dd3f484..afdc116 100644 (file)
 #include "ice_logs.h"
 #include "ice_ethdev.h"
 #include "ice_generic_flow.h"
+#include "ice_dcf_ethdev.h"
 
 
 #define MAX_QGRP_NUM_TYPE 7
+#define ICE_PPP_IPV4_PROTO     0x0021
+#define ICE_PPP_IPV6_PROTO     0x0057
+#define ICE_IPV4_PROTO_NVGRE   0x002F
 
 #define ICE_SW_INSET_ETHER ( \
        ICE_INSET_DMAC | ICE_INSET_SMAC | ICE_INSET_ETHERTYPE)
        ICE_INSET_VLAN_OUTER | ICE_INSET_VLAN_INNER | \
        ICE_INSET_DMAC | ICE_INSET_ETHERTYPE | ICE_INSET_PPPOE_SESSION | \
        ICE_INSET_PPPOE_PROTO)
+#define ICE_SW_INSET_MAC_PPPOE_IPV4 ( \
+       ICE_SW_INSET_MAC_PPPOE | ICE_SW_INSET_MAC_IPV4)
+#define ICE_SW_INSET_MAC_PPPOE_IPV4_TCP ( \
+       ICE_SW_INSET_MAC_PPPOE | ICE_SW_INSET_MAC_IPV4_TCP)
+#define ICE_SW_INSET_MAC_PPPOE_IPV4_UDP ( \
+       ICE_SW_INSET_MAC_PPPOE | ICE_SW_INSET_MAC_IPV4_UDP)
+#define ICE_SW_INSET_MAC_PPPOE_IPV6 ( \
+       ICE_SW_INSET_MAC_PPPOE | ICE_SW_INSET_MAC_IPV6)
+#define ICE_SW_INSET_MAC_PPPOE_IPV6_TCP ( \
+       ICE_SW_INSET_MAC_PPPOE | ICE_SW_INSET_MAC_IPV6_TCP)
+#define ICE_SW_INSET_MAC_PPPOE_IPV6_UDP ( \
+       ICE_SW_INSET_MAC_PPPOE | ICE_SW_INSET_MAC_IPV6_UDP)
 #define ICE_SW_INSET_MAC_IPV4_ESP ( \
        ICE_SW_INSET_MAC_IPV4 | ICE_INSET_ESP_SPI)
 #define ICE_SW_INSET_MAC_IPV6_ESP ( \
@@ -154,10 +170,6 @@ ice_pattern_match_item ice_switch_pattern_dist_comms[] = {
                        ICE_SW_INSET_DIST_NVGRE_IPV4_UDP, ICE_INSET_NONE},
        {pattern_eth_ipv4_nvgre_eth_ipv4_tcp,
                        ICE_SW_INSET_DIST_NVGRE_IPV4_TCP, ICE_INSET_NONE},
-       {pattern_eth_pppoed,
-                       ICE_SW_INSET_MAC_PPPOE, ICE_INSET_NONE},
-       {pattern_eth_vlan_pppoed,
-                       ICE_SW_INSET_MAC_PPPOE, ICE_INSET_NONE},
        {pattern_eth_pppoes,
                        ICE_SW_INSET_MAC_PPPOE, ICE_INSET_NONE},
        {pattern_eth_vlan_pppoes,
@@ -166,6 +178,30 @@ ice_pattern_match_item ice_switch_pattern_dist_comms[] = {
                        ICE_SW_INSET_MAC_PPPOE_PROTO, ICE_INSET_NONE},
        {pattern_eth_vlan_pppoes_proto,
                        ICE_SW_INSET_MAC_PPPOE_PROTO, ICE_INSET_NONE},
+       {pattern_eth_pppoes_ipv4,
+                       ICE_SW_INSET_MAC_PPPOE_IPV4, ICE_INSET_NONE},
+       {pattern_eth_pppoes_ipv4_tcp,
+                       ICE_SW_INSET_MAC_PPPOE_IPV4_TCP, ICE_INSET_NONE},
+       {pattern_eth_pppoes_ipv4_udp,
+                       ICE_SW_INSET_MAC_PPPOE_IPV4_UDP, ICE_INSET_NONE},
+       {pattern_eth_pppoes_ipv6,
+                       ICE_SW_INSET_MAC_PPPOE_IPV6, ICE_INSET_NONE},
+       {pattern_eth_pppoes_ipv6_tcp,
+                       ICE_SW_INSET_MAC_PPPOE_IPV6_TCP, ICE_INSET_NONE},
+       {pattern_eth_pppoes_ipv6_udp,
+                       ICE_SW_INSET_MAC_PPPOE_IPV6_UDP, ICE_INSET_NONE},
+       {pattern_eth_vlan_pppoes_ipv4,
+                       ICE_SW_INSET_MAC_PPPOE_IPV4, ICE_INSET_NONE},
+       {pattern_eth_vlan_pppoes_ipv4_tcp,
+                       ICE_SW_INSET_MAC_PPPOE_IPV4_TCP, ICE_INSET_NONE},
+       {pattern_eth_vlan_pppoes_ipv4_udp,
+                       ICE_SW_INSET_MAC_PPPOE_IPV4_UDP, ICE_INSET_NONE},
+       {pattern_eth_vlan_pppoes_ipv6,
+                       ICE_SW_INSET_MAC_PPPOE_IPV6, ICE_INSET_NONE},
+       {pattern_eth_vlan_pppoes_ipv6_tcp,
+                       ICE_SW_INSET_MAC_PPPOE_IPV6_TCP, ICE_INSET_NONE},
+       {pattern_eth_vlan_pppoes_ipv6_udp,
+                       ICE_SW_INSET_MAC_PPPOE_IPV6_UDP, ICE_INSET_NONE},
        {pattern_eth_ipv4_esp,
                        ICE_SW_INSET_MAC_IPV4_ESP, ICE_INSET_NONE},
        {pattern_eth_ipv4_udp_esp,
@@ -254,10 +290,6 @@ ice_pattern_match_item ice_switch_pattern_perm[] = {
                        ICE_SW_INSET_PERM_TUNNEL_IPV4_UDP, ICE_INSET_NONE},
        {pattern_eth_ipv4_nvgre_eth_ipv4_tcp,
                        ICE_SW_INSET_PERM_TUNNEL_IPV4_TCP, ICE_INSET_NONE},
-       {pattern_eth_pppoed,
-                       ICE_SW_INSET_MAC_PPPOE, ICE_INSET_NONE},
-       {pattern_eth_vlan_pppoed,
-                       ICE_SW_INSET_MAC_PPPOE, ICE_INSET_NONE},
        {pattern_eth_pppoes,
                        ICE_SW_INSET_MAC_PPPOE, ICE_INSET_NONE},
        {pattern_eth_vlan_pppoes,
@@ -266,6 +298,30 @@ ice_pattern_match_item ice_switch_pattern_perm[] = {
                        ICE_SW_INSET_MAC_PPPOE_PROTO, ICE_INSET_NONE},
        {pattern_eth_vlan_pppoes_proto,
                        ICE_SW_INSET_MAC_PPPOE_PROTO, ICE_INSET_NONE},
+       {pattern_eth_pppoes_ipv4,
+                       ICE_SW_INSET_MAC_PPPOE_IPV4, ICE_INSET_NONE},
+       {pattern_eth_pppoes_ipv4_tcp,
+                       ICE_SW_INSET_MAC_PPPOE_IPV4_TCP, ICE_INSET_NONE},
+       {pattern_eth_pppoes_ipv4_udp,
+                       ICE_SW_INSET_MAC_PPPOE_IPV4_UDP, ICE_INSET_NONE},
+       {pattern_eth_pppoes_ipv6,
+                       ICE_SW_INSET_MAC_PPPOE_IPV6, ICE_INSET_NONE},
+       {pattern_eth_pppoes_ipv6_tcp,
+                       ICE_SW_INSET_MAC_PPPOE_IPV6_TCP, ICE_INSET_NONE},
+       {pattern_eth_pppoes_ipv6_udp,
+                       ICE_SW_INSET_MAC_PPPOE_IPV6_UDP, ICE_INSET_NONE},
+       {pattern_eth_vlan_pppoes_ipv4,
+                       ICE_SW_INSET_MAC_PPPOE_IPV4, ICE_INSET_NONE},
+       {pattern_eth_vlan_pppoes_ipv4_tcp,
+                       ICE_SW_INSET_MAC_PPPOE_IPV4_TCP, ICE_INSET_NONE},
+       {pattern_eth_vlan_pppoes_ipv4_udp,
+                       ICE_SW_INSET_MAC_PPPOE_IPV4_UDP, ICE_INSET_NONE},
+       {pattern_eth_vlan_pppoes_ipv6,
+                       ICE_SW_INSET_MAC_PPPOE_IPV6, ICE_INSET_NONE},
+       {pattern_eth_vlan_pppoes_ipv6_tcp,
+                       ICE_SW_INSET_MAC_PPPOE_IPV6_TCP, ICE_INSET_NONE},
+       {pattern_eth_vlan_pppoes_ipv6_udp,
+                       ICE_SW_INSET_MAC_PPPOE_IPV6_UDP, ICE_INSET_NONE},
        {pattern_eth_ipv4_esp,
                        ICE_SW_INSET_MAC_IPV4_ESP, ICE_INSET_NONE},
        {pattern_eth_ipv4_udp_esp,
@@ -416,13 +472,18 @@ ice_switch_inset_get(const struct rte_flow_item pattern[],
        const struct rte_flow_item_l2tpv3oip *l2tp_spec, *l2tp_mask;
        const struct rte_flow_item_pfcp *pfcp_spec, *pfcp_mask;
        uint64_t input_set = ICE_INSET_NONE;
-       uint16_t j, t = 0;
-       bool profile_rule = 0;
+       bool pppoe_elem_valid = 0;
+       bool pppoe_patt_valid = 0;
+       bool pppoe_prot_valid = 0;
        bool tunnel_valid = 0;
-       bool pppoe_valid = 0;
+       bool profile_rule = 0;
+       bool nvgre_valid = 0;
+       bool vxlan_valid = 0;
        bool ipv6_valiad = 0;
        bool ipv4_valiad = 0;
        bool udp_valiad = 0;
+       bool tcp_valiad = 0;
+       uint16_t j, t = 0;
 
        for (item = pattern; item->type !=
                        RTE_FLOW_ITEM_TYPE_END; item++) {
@@ -575,6 +636,10 @@ ice_switch_inset_get(const struct rte_flow_item pattern[],
                                        list[t].m_u.ipv4_hdr.protocol =
                                                ipv4_mask->hdr.next_proto_id;
                                }
+                               if ((ipv4_spec->hdr.next_proto_id &
+                                       ipv4_mask->hdr.next_proto_id) ==
+                                       ICE_IPV4_PROTO_NVGRE)
+                                       *tun_type = ICE_SW_TUN_AND_NON_TUN;
                                if (ipv4_mask->hdr.type_of_service) {
                                        list[t].h_u.ipv4_hdr.tos =
                                                ipv4_spec->hdr.type_of_service;
@@ -752,6 +817,7 @@ ice_switch_inset_get(const struct rte_flow_item pattern[],
                case RTE_FLOW_ITEM_TYPE_TCP:
                        tcp_spec = item->spec;
                        tcp_mask = item->mask;
+                       tcp_valiad = 1;
                        if (tcp_spec && tcp_mask) {
                                /* Check TCP mask and update input set */
                                if (tcp_mask->hdr.sent_seq ||
@@ -860,7 +926,7 @@ ice_switch_inset_get(const struct rte_flow_item pattern[],
                                           "Invalid VXLAN item");
                                return 0;
                        }
-
+                       vxlan_valid = 1;
                        tunnel_valid = 1;
                        if (vxlan_spec && vxlan_mask) {
                                list[t].type = ICE_VXLAN;
@@ -897,6 +963,7 @@ ice_switch_inset_get(const struct rte_flow_item pattern[],
                                           "Invalid NVGRE item");
                                return 0;
                        }
+                       nvgre_valid = 1;
                        tunnel_valid = 1;
                        if (nvgre_spec && nvgre_mask) {
                                list[t].type = ICE_NVGRE;
@@ -969,6 +1036,7 @@ ice_switch_inset_get(const struct rte_flow_item pattern[],
                                        "Invalid pppoe item");
                                return 0;
                        }
+                       pppoe_patt_valid = 1;
                        if (pppoe_spec && pppoe_mask) {
                                /* Check pppoe mask and update input set */
                                if (pppoe_mask->length ||
@@ -989,7 +1057,7 @@ ice_switch_inset_get(const struct rte_flow_item pattern[],
                                        input_set |= ICE_INSET_PPPOE_SESSION;
                                }
                                t++;
-                               pppoe_valid = 1;
+                               pppoe_elem_valid = 1;
                        }
                        break;
 
@@ -1010,7 +1078,7 @@ ice_switch_inset_get(const struct rte_flow_item pattern[],
                                return 0;
                        }
                        if (pppoe_proto_spec && pppoe_proto_mask) {
-                               if (pppoe_valid)
+                               if (pppoe_elem_valid)
                                        t--;
                                list[t].type = ICE_PPPOE;
                                if (pppoe_proto_mask->proto_id) {
@@ -1019,9 +1087,21 @@ ice_switch_inset_get(const struct rte_flow_item pattern[],
                                        list[t].m_u.pppoe_hdr.ppp_prot_id =
                                                pppoe_proto_mask->proto_id;
                                        input_set |= ICE_INSET_PPPOE_PROTO;
+
+                                       pppoe_prot_valid = 1;
                                }
+                               if ((pppoe_proto_mask->proto_id &
+                                       pppoe_proto_spec->proto_id) !=
+                                           CPU_TO_BE16(ICE_PPP_IPV4_PROTO) &&
+                                       (pppoe_proto_mask->proto_id &
+                                       pppoe_proto_spec->proto_id) !=
+                                           CPU_TO_BE16(ICE_PPP_IPV6_PROTO))
+                                       *tun_type = ICE_SW_TUN_PPPOE_PAY;
+                               else
+                                       *tun_type = ICE_SW_TUN_PPPOE;
                                t++;
                        }
+
                        break;
 
                case RTE_FLOW_ITEM_TYPE_ESP:
@@ -1232,6 +1312,38 @@ ice_switch_inset_get(const struct rte_flow_item pattern[],
                }
        }
 
+       if (pppoe_patt_valid && !pppoe_prot_valid) {
+               if (ipv6_valiad && udp_valiad)
+                       *tun_type = ICE_SW_TUN_PPPOE_IPV6_UDP;
+               else if (ipv6_valiad && tcp_valiad)
+                       *tun_type = ICE_SW_TUN_PPPOE_IPV6_TCP;
+               else if (ipv4_valiad && udp_valiad)
+                       *tun_type = ICE_SW_TUN_PPPOE_IPV4_UDP;
+               else if (ipv4_valiad && tcp_valiad)
+                       *tun_type = ICE_SW_TUN_PPPOE_IPV4_TCP;
+               else if (ipv6_valiad)
+                       *tun_type = ICE_SW_TUN_PPPOE_IPV6;
+               else if (ipv4_valiad)
+                       *tun_type = ICE_SW_TUN_PPPOE_IPV4;
+               else
+                       *tun_type = ICE_SW_TUN_PPPOE;
+       }
+
+       if (*tun_type == ICE_NON_TUN) {
+               if (vxlan_valid)
+                       *tun_type = ICE_SW_TUN_VXLAN;
+               else if (nvgre_valid)
+                       *tun_type = ICE_SW_TUN_NVGRE;
+               else if (ipv4_valiad && tcp_valiad)
+                       *tun_type = ICE_SW_IPV4_TCP;
+               else if (ipv4_valiad && udp_valiad)
+                       *tun_type = ICE_SW_IPV4_UDP;
+               else if (ipv6_valiad && tcp_valiad)
+                       *tun_type = ICE_SW_IPV6_TCP;
+               else if (ipv6_valiad && udp_valiad)
+                       *tun_type = ICE_SW_IPV6_UDP;
+       }
+
        *lkups_num = t;
 
        return input_set;
@@ -1240,7 +1352,8 @@ out:
 }
 
 static int
-ice_switch_parse_dcf_action(const struct rte_flow_action *actions,
+ice_switch_parse_dcf_action(struct ice_dcf_adapter *ad,
+                           const struct rte_flow_action *actions,
                            struct rte_flow_error *error,
                            struct ice_adv_rule_info *rule_info)
 {
@@ -1255,7 +1368,11 @@ ice_switch_parse_dcf_action(const struct rte_flow_action *actions,
                case RTE_FLOW_ACTION_TYPE_VF:
                        rule_info->sw_act.fltr_act = ICE_FWD_TO_VSI;
                        act_vf = action->conf;
-                       rule_info->sw_act.vsi_handle = act_vf->id;
+                       if (act_vf->original)
+                               rule_info->sw_act.vsi_handle =
+                                       ad->real_hw.avf.bus.func;
+                       else
+                               rule_info->sw_act.vsi_handle = act_vf->id;
                        break;
                default:
                        rte_flow_error_set(error,
@@ -1388,7 +1505,7 @@ ice_switch_check_action(const struct rte_flow_action *actions,
                }
        }
 
-       if (actions_num > 1) {
+       if (actions_num != 1) {
                rte_flow_error_set(error,
                                   EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
                                   actions,
@@ -1438,18 +1555,11 @@ ice_switch_parse_pattern_action(struct ice_adapter *ad,
        const struct rte_flow_item *item = pattern;
        uint16_t item_num = 0;
        enum ice_sw_tunnel_type tun_type =
-               ICE_SW_TUN_AND_NON_TUN;
+                       ICE_NON_TUN;
        struct ice_pattern_match_item *pattern_match_item = NULL;
 
        for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
                item_num++;
-               if (item->type == RTE_FLOW_ITEM_TYPE_VXLAN)
-                       tun_type = ICE_SW_TUN_VXLAN;
-               if (item->type == RTE_FLOW_ITEM_TYPE_NVGRE)
-                       tun_type = ICE_SW_TUN_NVGRE;
-               if (item->type == RTE_FLOW_ITEM_TYPE_PPPOED ||
-                               item->type == RTE_FLOW_ITEM_TYPE_PPPOES)
-                       tun_type = ICE_SW_TUN_PPPOE;
                if (item->type == RTE_FLOW_ITEM_TYPE_ETH) {
                        const struct rte_flow_item_eth *eth_mask;
                        if (item->mask)
@@ -1515,7 +1625,8 @@ ice_switch_parse_pattern_action(struct ice_adapter *ad,
        }
 
        if (ad->hw.dcf_enabled)
-               ret = ice_switch_parse_dcf_action(actions, error, &rule_info);
+               ret = ice_switch_parse_dcf_action((void *)ad, actions, error,
+                                                 &rule_info);
        else
                ret = ice_switch_parse_action(pf, actions, error, &rule_info);
 
@@ -1577,6 +1688,9 @@ ice_switch_redirect(struct ice_adapter *ad,
        uint16_t lkups_cnt;
        int ret;
 
+       if (rdata->vsi_handle != rd->vsi_handle)
+               return 0;
+
        sw = hw->switch_info;
        if (!sw->recp_list[rdata->rid].recp_created)
                return -EINVAL;
@@ -1588,25 +1702,32 @@ ice_switch_redirect(struct ice_adapter *ad,
        LIST_FOR_EACH_ENTRY(list_itr, list_head, ice_adv_fltr_mgmt_list_entry,
                            list_entry) {
                rinfo = list_itr->rule_info;
-               if (rinfo.fltr_rule_id == rdata->rule_id &&
+               if ((rinfo.fltr_rule_id == rdata->rule_id &&
                    rinfo.sw_act.fltr_act == ICE_FWD_TO_VSI &&
-                   rinfo.sw_act.vsi_handle == rd->vsi_handle) {
+                   rinfo.sw_act.vsi_handle == rd->vsi_handle) ||
+                   (rinfo.fltr_rule_id == rdata->rule_id &&
+                   rinfo.sw_act.fltr_act == ICE_FWD_TO_VSI_LIST)){
                        lkups_cnt = list_itr->lkups_cnt;
                        lkups_dp = (struct ice_adv_lkup_elem *)
                                ice_memdup(hw, list_itr->lkups,
                                           sizeof(*list_itr->lkups) *
                                           lkups_cnt, ICE_NONDMA_TO_NONDMA);
+
                        if (!lkups_dp) {
                                PMD_DRV_LOG(ERR, "Failed to allocate memory.");
                                return -EINVAL;
                        }
 
+                       if (rinfo.sw_act.fltr_act == ICE_FWD_TO_VSI_LIST) {
+                               rinfo.sw_act.vsi_handle = rd->vsi_handle;
+                               rinfo.sw_act.fltr_act = ICE_FWD_TO_VSI;
+                       }
                        break;
                }
        }
 
        if (!lkups_dp)
-               return 0;
+               return -EINVAL;
 
        /* Remove the old rule */
        ret = ice_rem_adv_rule(hw, list_itr->lkups,