1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(C) 2019 Marvell International Ltd.
5 #include "otx2_ethdev.h"
8 const struct rte_flow_item *
9 otx2_flow_skip_void_and_any_items(const struct rte_flow_item *pattern)
11 while ((pattern->type == RTE_FLOW_ITEM_TYPE_VOID) ||
12 (pattern->type == RTE_FLOW_ITEM_TYPE_ANY))
19 * Tunnel+ESP, Tunnel+ICMP4/6, Tunnel+TCP, Tunnel+UDP,
23 otx2_flow_parse_lh(struct otx2_parse_state *pst)
25 struct otx2_flow_item_info info;
33 info.hw_mask = &hw_mask;
39 switch (pst->pattern->type) {
40 case RTE_FLOW_ITEM_TYPE_UDP:
41 lt = NPC_LT_LH_TU_UDP;
42 info.def_mask = &rte_flow_item_udp_mask;
43 info.len = sizeof(struct rte_flow_item_udp);
45 case RTE_FLOW_ITEM_TYPE_TCP:
46 lt = NPC_LT_LH_TU_TCP;
47 info.def_mask = &rte_flow_item_tcp_mask;
48 info.len = sizeof(struct rte_flow_item_tcp);
50 case RTE_FLOW_ITEM_TYPE_SCTP:
51 lt = NPC_LT_LH_TU_SCTP;
52 info.def_mask = &rte_flow_item_sctp_mask;
53 info.len = sizeof(struct rte_flow_item_sctp);
55 case RTE_FLOW_ITEM_TYPE_ESP:
56 lt = NPC_LT_LH_TU_ESP;
57 info.def_mask = &rte_flow_item_esp_mask;
58 info.len = sizeof(struct rte_flow_item_esp);
64 otx2_flow_get_hw_supp_mask(pst, &info, lid, lt);
65 rc = otx2_flow_parse_item_basic(pst->pattern, &info, pst->error);
69 return otx2_flow_update_parse_state(pst, &info, lid, lt, 0);
72 /* Tunnel+IPv4, Tunnel+IPv6 */
74 otx2_flow_parse_lg(struct otx2_parse_state *pst)
76 struct otx2_flow_item_info info;
84 info.hw_mask = &hw_mask;
90 if (pst->pattern->type == RTE_FLOW_ITEM_TYPE_IPV4) {
92 info.def_mask = &rte_flow_item_ipv4_mask;
93 info.len = sizeof(struct rte_flow_item_ipv4);
94 } else if (pst->pattern->type == RTE_FLOW_ITEM_TYPE_IPV6) {
95 lt = NPC_LT_LG_TU_IP6;
96 info.def_mask = &rte_flow_item_ipv6_mask;
97 info.len = sizeof(struct rte_flow_item_ipv6);
99 /* There is no tunneled IP header */
103 otx2_flow_get_hw_supp_mask(pst, &info, lid, lt);
104 rc = otx2_flow_parse_item_basic(pst->pattern, &info, pst->error);
108 return otx2_flow_update_parse_state(pst, &info, lid, lt, 0);
113 otx2_flow_parse_lf(struct otx2_parse_state *pst)
115 const struct rte_flow_item *pattern, *last_pattern;
116 struct rte_flow_item_eth hw_mask;
117 struct otx2_flow_item_info info;
122 /* We hit this layer if there is a tunneling protocol */
126 if (pst->pattern->type != RTE_FLOW_ITEM_TYPE_ETH)
130 lt = NPC_LT_LF_TU_ETHER;
133 info.def_mask = &rte_flow_item_vlan_mask;
134 /* No match support for vlan tags */
136 info.len = sizeof(struct rte_flow_item_vlan);
141 /* Look ahead and find out any VLAN tags. These can be
142 * detected but no data matching is available.
144 last_pattern = pst->pattern;
145 pattern = pst->pattern + 1;
146 pattern = otx2_flow_skip_void_and_any_items(pattern);
147 while (pattern->type == RTE_FLOW_ITEM_TYPE_VLAN) {
149 rc = otx2_flow_parse_item_basic(pattern, &info, pst->error);
152 last_pattern = pattern;
154 pattern = otx2_flow_skip_void_and_any_items(pattern);
156 otx2_npc_dbg("Nr_vlans = %d", nr_vlans);
161 lflags = NPC_F_TU_ETHER_CTAG;
164 lflags = NPC_F_TU_ETHER_STAG_CTAG;
167 rte_flow_error_set(pst->error, ENOTSUP,
168 RTE_FLOW_ERROR_TYPE_ITEM,
170 "more than 2 vlans with tunneled Ethernet "
175 info.def_mask = &rte_flow_item_eth_mask;
176 info.hw_mask = &hw_mask;
177 info.len = sizeof(struct rte_flow_item_eth);
179 otx2_flow_get_hw_supp_mask(pst, &info, lid, lt);
183 rc = otx2_flow_parse_item_basic(pst->pattern, &info, pst->error);
187 pst->pattern = last_pattern;
189 return otx2_flow_update_parse_state(pst, &info, lid, lt, lflags);
193 otx2_flow_parse_le(struct otx2_parse_state *pst)
196 * We are positioned at UDP. Scan ahead and look for
197 * UDP encapsulated tunnel protocols. If available,
198 * parse them. In that case handle this:
199 * - RTE spec assumes we point to tunnel header.
200 * - NPC parser provides offset from UDP header.
204 * Note: Add support to GENEVE, VXLAN_GPE when we
207 * Note: Better to split flags into two nibbles:
208 * - Higher nibble can have flags
209 * - Lower nibble to further enumerate protocols
210 * and have flags based extraction
212 const struct rte_flow_item *pattern = pst->pattern;
213 struct otx2_flow_item_info info;
221 if (pst->pattern->type == RTE_FLOW_ITEM_TYPE_MPLS)
222 return otx2_flow_parse_mpls(pst, NPC_LID_LE);
227 info.def_mask = NULL;
233 /* Ensure we are not matching anything in UDP */
234 rc = otx2_flow_parse_item_basic(pattern, &info, pst->error);
238 info.hw_mask = &hw_mask;
239 pattern = otx2_flow_skip_void_and_any_items(pattern);
240 otx2_npc_dbg("Pattern->type = %d", pattern->type);
241 switch (pattern->type) {
242 case RTE_FLOW_ITEM_TYPE_VXLAN:
243 lflags = NPC_F_UDP_VXLAN;
244 info.def_mask = &rte_flow_item_vxlan_mask;
245 info.len = sizeof(struct rte_flow_item_vxlan);
246 lt = NPC_LT_LE_VXLAN;
248 case RTE_FLOW_ITEM_TYPE_GTPC:
249 lflags = NPC_F_UDP_GTP_GTPC;
250 info.def_mask = &rte_flow_item_gtp_mask;
251 info.len = sizeof(struct rte_flow_item_gtp);
254 case RTE_FLOW_ITEM_TYPE_GTPU:
255 lflags = NPC_F_UDP_GTP_GTPU_G_PDU;
256 info.def_mask = &rte_flow_item_gtp_mask;
257 info.len = sizeof(struct rte_flow_item_gtp);
260 case RTE_FLOW_ITEM_TYPE_GENEVE:
261 lflags = NPC_F_UDP_GENEVE;
262 info.def_mask = &rte_flow_item_geneve_mask;
263 info.len = sizeof(struct rte_flow_item_geneve);
264 lt = NPC_LT_LE_GENEVE;
266 case RTE_FLOW_ITEM_TYPE_VXLAN_GPE:
267 lflags = NPC_F_UDP_VXLANGPE;
268 info.def_mask = &rte_flow_item_vxlan_gpe_mask;
269 info.len = sizeof(struct rte_flow_item_vxlan_gpe);
270 lt = NPC_LT_LE_VXLANGPE;
278 otx2_flow_get_hw_supp_mask(pst, &info, lid, lt);
279 rc = otx2_flow_parse_item_basic(pattern, &info, pst->error);
283 return otx2_flow_update_parse_state(pst, &info, lid, lt, lflags);
287 flow_parse_mpls_label_stack(struct otx2_parse_state *pst, int *flag)
290 const struct rte_flow_item *pattern = pst->pattern;
291 struct otx2_flow_item_info info;
293 uint8_t flag_list[] = {0, NPC_F_MPLS_2_LABELS,
294 NPC_F_MPLS_3_LABELS, NPC_F_MPLS_4_LABELS};
297 * pst->pattern points to first MPLS label. We only check
298 * that subsequent labels do not have anything to match.
300 info.def_mask = &rte_flow_item_mpls_mask;
302 info.len = sizeof(struct rte_flow_item_mpls);
307 while (pattern->type == RTE_FLOW_ITEM_TYPE_MPLS) {
310 /* Basic validation of 2nd/3rd/4th mpls item */
312 rc = otx2_flow_parse_item_basic(pattern, &info,
317 pst->last_pattern = pattern;
319 pattern = otx2_flow_skip_void_and_any_items(pattern);
323 rte_flow_error_set(pst->error, ENOTSUP,
324 RTE_FLOW_ERROR_TYPE_ITEM,
326 "more than 4 mpls labels not supported");
330 *flag = flag_list[nr_labels - 1];
335 otx2_flow_parse_mpls(struct otx2_parse_state *pst, int lid)
337 /* Find number of MPLS labels */
338 struct rte_flow_item_mpls hw_mask;
339 struct otx2_flow_item_info info;
345 if (lid == NPC_LID_LC)
347 else if (lid == NPC_LID_LD)
348 lt = NPC_LT_LD_TU_MPLS_IN_IP;
350 lt = NPC_LT_LE_TU_MPLS_IN_UDP;
352 /* Prepare for parsing the first item */
353 info.def_mask = &rte_flow_item_mpls_mask;
354 info.hw_mask = &hw_mask;
355 info.len = sizeof(struct rte_flow_item_mpls);
360 otx2_flow_get_hw_supp_mask(pst, &info, lid, lt);
361 rc = otx2_flow_parse_item_basic(pst->pattern, &info, pst->error);
366 * Parse for more labels.
367 * This sets lflags and pst->last_pattern correctly.
369 rc = flow_parse_mpls_label_stack(pst, &lflags);
374 pst->pattern = pst->last_pattern;
376 return otx2_flow_update_parse_state(pst, &info, lid, lt, lflags);
380 * ICMP, ICMP6, UDP, TCP, SCTP, VXLAN, GRE, NVGRE,
381 * GTP, GTPC, GTPU, ESP
383 * Note: UDP tunnel protocols are identified by flags.
384 * LPTR for these protocol still points to UDP
385 * header. Need flag based extraction to support
389 otx2_flow_parse_ld(struct otx2_parse_state *pst)
391 char hw_mask[NPC_MAX_EXTRACT_DATA_LEN];
392 struct otx2_flow_item_info info;
397 /* We have already parsed MPLS or IPv4/v6 followed
398 * by MPLS or IPv4/v6. Subsequent TCP/UDP etc
399 * would be parsed as tunneled versions. Skip
400 * this layer, except for tunneled MPLS. If LC is
401 * MPLS, we have anyway skipped all stacked MPLS
404 if (pst->pattern->type == RTE_FLOW_ITEM_TYPE_MPLS)
405 return otx2_flow_parse_mpls(pst, NPC_LID_LD);
408 info.hw_mask = &hw_mask;
411 info.def_mask = NULL;
418 otx2_npc_dbg("Pst->pattern->type = %d", pst->pattern->type);
419 switch (pst->pattern->type) {
420 case RTE_FLOW_ITEM_TYPE_ICMP:
421 if (pst->lt[NPC_LID_LC] == NPC_LT_LC_IP6)
422 lt = NPC_LT_LD_ICMP6;
425 info.def_mask = &rte_flow_item_icmp_mask;
426 info.len = sizeof(struct rte_flow_item_icmp);
428 case RTE_FLOW_ITEM_TYPE_UDP:
430 info.def_mask = &rte_flow_item_udp_mask;
431 info.len = sizeof(struct rte_flow_item_udp);
433 case RTE_FLOW_ITEM_TYPE_TCP:
435 info.def_mask = &rte_flow_item_tcp_mask;
436 info.len = sizeof(struct rte_flow_item_tcp);
438 case RTE_FLOW_ITEM_TYPE_SCTP:
440 info.def_mask = &rte_flow_item_sctp_mask;
441 info.len = sizeof(struct rte_flow_item_sctp);
443 case RTE_FLOW_ITEM_TYPE_ESP:
445 info.def_mask = &rte_flow_item_esp_mask;
446 info.len = sizeof(struct rte_flow_item_esp);
448 case RTE_FLOW_ITEM_TYPE_GRE:
450 info.def_mask = &rte_flow_item_gre_mask;
451 info.len = sizeof(struct rte_flow_item_gre);
453 case RTE_FLOW_ITEM_TYPE_NVGRE:
455 lflags = NPC_F_GRE_NVGRE;
456 info.def_mask = &rte_flow_item_nvgre_mask;
457 info.len = sizeof(struct rte_flow_item_nvgre);
458 /* Further IP/Ethernet are parsed as tunneled */
465 otx2_flow_get_hw_supp_mask(pst, &info, lid, lt);
466 rc = otx2_flow_parse_item_basic(pst->pattern, &info, pst->error);
470 return otx2_flow_update_parse_state(pst, &info, lid, lt, lflags);
474 flow_check_lc_ip_tunnel(struct otx2_parse_state *pst)
476 const struct rte_flow_item *pattern = pst->pattern + 1;
478 pattern = otx2_flow_skip_void_and_any_items(pattern);
479 if (pattern->type == RTE_FLOW_ITEM_TYPE_MPLS ||
480 pattern->type == RTE_FLOW_ITEM_TYPE_IPV4 ||
481 pattern->type == RTE_FLOW_ITEM_TYPE_IPV6)
485 /* Outer IPv4, Outer IPv6, MPLS, ARP */
487 otx2_flow_parse_lc(struct otx2_parse_state *pst)
489 uint8_t hw_mask[NPC_MAX_EXTRACT_DATA_LEN];
490 struct otx2_flow_item_info info;
494 if (pst->pattern->type == RTE_FLOW_ITEM_TYPE_MPLS)
495 return otx2_flow_parse_mpls(pst, NPC_LID_LC);
497 info.hw_mask = &hw_mask;
503 switch (pst->pattern->type) {
504 case RTE_FLOW_ITEM_TYPE_IPV4:
506 info.def_mask = &rte_flow_item_ipv4_mask;
507 info.len = sizeof(struct rte_flow_item_ipv4);
509 case RTE_FLOW_ITEM_TYPE_IPV6:
512 info.def_mask = &rte_flow_item_ipv6_mask;
513 info.len = sizeof(struct rte_flow_item_ipv6);
515 case RTE_FLOW_ITEM_TYPE_ARP_ETH_IPV4:
517 info.def_mask = &rte_flow_item_arp_eth_ipv4_mask;
518 info.len = sizeof(struct rte_flow_item_arp_eth_ipv4);
521 /* No match at this layer */
525 /* Identify if IP tunnels MPLS or IPv4/v6 */
526 flow_check_lc_ip_tunnel(pst);
528 otx2_flow_get_hw_supp_mask(pst, &info, lid, lt);
529 rc = otx2_flow_parse_item_basic(pst->pattern, &info, pst->error);
533 return otx2_flow_update_parse_state(pst, &info, lid, lt, 0);
538 otx2_flow_parse_lb(struct otx2_parse_state *pst)
540 const struct rte_flow_item *pattern = pst->pattern;
541 const struct rte_flow_item *last_pattern;
542 char hw_mask[NPC_MAX_EXTRACT_DATA_LEN];
543 struct otx2_flow_item_info info;
550 info.hw_hdr_len = NPC_TPID_LENGTH;
554 last_pattern = pattern;
556 if (pst->pattern->type == RTE_FLOW_ITEM_TYPE_VLAN) {
557 /* RTE vlan is either 802.1q or 802.1ad,
558 * this maps to either CTAG/STAG. We need to decide
559 * based on number of VLANS present. Matching is
560 * supported on first tag only.
562 info.def_mask = &rte_flow_item_vlan_mask;
564 info.len = sizeof(struct rte_flow_item_vlan);
566 pattern = pst->pattern;
567 while (pattern->type == RTE_FLOW_ITEM_TYPE_VLAN) {
570 /* Basic validation of 2nd/3rd vlan item */
572 otx2_npc_dbg("Vlans = %d", nr_vlans);
573 rc = otx2_flow_parse_item_basic(pattern, &info,
578 last_pattern = pattern;
580 pattern = otx2_flow_skip_void_and_any_items(pattern);
589 lflags = NPC_F_STAG_CTAG;
593 lflags = NPC_F_STAG_STAG_CTAG;
596 rte_flow_error_set(pst->error, ENOTSUP,
597 RTE_FLOW_ERROR_TYPE_ITEM,
599 "more than 3 vlans not supported");
602 } else if (pst->pattern->type == RTE_FLOW_ITEM_TYPE_E_TAG) {
603 /* we can support ETAG and match a subsequent CTAG
604 * without any matching support.
609 last_pattern = pst->pattern;
610 pattern = otx2_flow_skip_void_and_any_items(pst->pattern + 1);
611 if (pattern->type == RTE_FLOW_ITEM_TYPE_VLAN) {
612 info.def_mask = &rte_flow_item_vlan_mask;
613 /* set supported mask to NULL for vlan tag */
615 info.len = sizeof(struct rte_flow_item_vlan);
616 rc = otx2_flow_parse_item_basic(pattern, &info,
621 lflags = NPC_F_ETAG_CTAG;
622 last_pattern = pattern;
625 info.def_mask = &rte_flow_item_e_tag_mask;
626 info.len = sizeof(struct rte_flow_item_e_tag);
631 info.hw_mask = &hw_mask;
634 otx2_flow_get_hw_supp_mask(pst, &info, lid, lt);
636 rc = otx2_flow_parse_item_basic(pst->pattern, &info, pst->error);
640 /* Point pattern to last item consumed */
641 pst->pattern = last_pattern;
642 return otx2_flow_update_parse_state(pst, &info, lid, lt, lflags);
646 otx2_flow_parse_la(struct otx2_parse_state *pst)
648 struct rte_flow_item_eth hw_mask;
649 struct otx2_flow_item_info info;
653 /* Identify the pattern type into lid, lt */
654 if (pst->pattern->type != RTE_FLOW_ITEM_TYPE_ETH)
658 lt = NPC_LT_LA_ETHER;
661 if (pst->flow->nix_intf == NIX_INTF_TX) {
662 lt = NPC_LT_LA_IH_NIX_ETHER;
663 info.hw_hdr_len = NPC_IH_LENGTH;
666 /* Prepare for parsing the item */
667 info.def_mask = &rte_flow_item_eth_mask;
668 info.hw_mask = &hw_mask;
669 info.len = sizeof(struct rte_flow_item_eth);
670 otx2_flow_get_hw_supp_mask(pst, &info, lid, lt);
674 /* Basic validation of item parameters */
675 rc = otx2_flow_parse_item_basic(pst->pattern, &info, pst->error);
679 /* Update pst if not validate only? clash check? */
680 return otx2_flow_update_parse_state(pst, &info, lid, lt, 0);
684 parse_rss_action(struct rte_eth_dev *dev,
685 const struct rte_flow_attr *attr,
686 const struct rte_flow_action *act,
687 struct rte_flow_error *error)
689 struct otx2_eth_dev *hw = dev->data->dev_private;
690 struct otx2_rss_info *rss_info = &hw->rss_info;
691 const struct rte_flow_action_rss *rss;
694 rss = (const struct rte_flow_action_rss *)act->conf;
698 return rte_flow_error_set(error, EINVAL,
699 RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
700 attr, "No support of RSS in egress");
703 if (dev->data->dev_conf.rxmode.mq_mode != ETH_MQ_RX_RSS)
704 return rte_flow_error_set(error, ENOTSUP,
705 RTE_FLOW_ERROR_TYPE_ACTION,
706 act, "multi-queue mode is disabled");
708 /* Parse RSS related parameters from configuration */
709 if (!rss || !rss->queue_num)
710 return rte_flow_error_set(error, EINVAL,
711 RTE_FLOW_ERROR_TYPE_ACTION,
712 act, "no valid queues");
714 if (rss->func != RTE_ETH_HASH_FUNCTION_DEFAULT)
715 return rte_flow_error_set(error, ENOTSUP,
716 RTE_FLOW_ERROR_TYPE_ACTION, act,
717 "non-default RSS hash functions"
718 " are not supported");
720 if (rss->key_len && rss->key_len > RTE_DIM(rss_info->key))
721 return rte_flow_error_set(error, ENOTSUP,
722 RTE_FLOW_ERROR_TYPE_ACTION, act,
723 "RSS hash key too large");
725 if (rss->queue_num > rss_info->rss_size)
726 return rte_flow_error_set
727 (error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION, act,
728 "too many queues for RSS context");
730 for (i = 0; i < rss->queue_num; i++) {
731 if (rss->queue[i] >= dev->data->nb_rx_queues)
732 return rte_flow_error_set(error, EINVAL,
733 RTE_FLOW_ERROR_TYPE_ACTION,
735 "queue id > max number"
743 otx2_flow_parse_actions(struct rte_eth_dev *dev,
744 const struct rte_flow_attr *attr,
745 const struct rte_flow_action actions[],
746 struct rte_flow_error *error,
747 struct rte_flow *flow)
749 struct otx2_eth_dev *hw = dev->data->dev_private;
750 struct otx2_npc_flow_info *npc = &hw->npc_flow;
751 const struct rte_flow_action_count *act_count;
752 const struct rte_flow_action_mark *act_mark;
753 const struct rte_flow_action_queue *act_q;
754 const struct rte_flow_action_vf *vf_act;
755 const char *errmsg = NULL;
756 int sel_act, req_act = 0;
757 uint16_t pf_func, vf_id;
762 /* Initialize actions */
763 flow->ctr_id = NPC_COUNTER_NONE;
764 pf_func = otx2_pfvf_func(hw->pf, hw->vf);
766 for (; actions->type != RTE_FLOW_ACTION_TYPE_END; actions++) {
767 otx2_npc_dbg("Action type = %d", actions->type);
769 switch (actions->type) {
770 case RTE_FLOW_ACTION_TYPE_VOID:
772 case RTE_FLOW_ACTION_TYPE_MARK:
774 (const struct rte_flow_action_mark *)actions->conf;
776 /* We have only 16 bits. Use highest val for flag */
777 if (act_mark->id > (OTX2_FLOW_FLAG_VAL - 2)) {
778 errmsg = "mark value must be < 0xfffe";
782 mark = act_mark->id + 1;
783 req_act |= OTX2_FLOW_ACT_MARK;
784 rte_atomic32_inc(&npc->mark_actions);
787 case RTE_FLOW_ACTION_TYPE_FLAG:
788 mark = OTX2_FLOW_FLAG_VAL;
789 req_act |= OTX2_FLOW_ACT_FLAG;
790 rte_atomic32_inc(&npc->mark_actions);
793 case RTE_FLOW_ACTION_TYPE_COUNT:
795 (const struct rte_flow_action_count *)
798 if (act_count->shared == 1) {
799 errmsg = "Shared Counters not supported";
803 /* Indicates, need a counter */
805 req_act |= OTX2_FLOW_ACT_COUNT;
808 case RTE_FLOW_ACTION_TYPE_DROP:
809 req_act |= OTX2_FLOW_ACT_DROP;
812 case RTE_FLOW_ACTION_TYPE_PF:
813 req_act |= OTX2_FLOW_ACT_PF;
817 case RTE_FLOW_ACTION_TYPE_VF:
818 vf_act = (const struct rte_flow_action_vf *)
820 req_act |= OTX2_FLOW_ACT_VF;
821 if (vf_act->original == 0) {
822 vf_id = (vf_act->id & RVU_PFVF_FUNC_MASK) + 1;
823 if (vf_id >= hw->maxvf) {
824 errmsg = "invalid vf specified";
829 pf_func = (pf_func | vf_id);
833 case RTE_FLOW_ACTION_TYPE_QUEUE:
834 /* Applicable only to ingress flow */
835 act_q = (const struct rte_flow_action_queue *)
838 if (rq >= dev->data->nb_rx_queues) {
839 errmsg = "invalid queue index";
843 req_act |= OTX2_FLOW_ACT_QUEUE;
846 case RTE_FLOW_ACTION_TYPE_RSS:
847 errcode = parse_rss_action(dev, attr, actions, error);
851 req_act |= OTX2_FLOW_ACT_RSS;
854 case RTE_FLOW_ACTION_TYPE_SECURITY:
855 /* Assumes user has already configured security
856 * session for this flow. Associated conf is
857 * opaque. When RTE security is implemented for otx2,
858 * we need to verify that for specified security
861 * RTE_SECURITY_ACTION_TYPE_INLINE_PROTOCOL &&
862 * session_protocol ==
863 * RTE_SECURITY_PROTOCOL_IPSEC
865 * RSS is not supported with inline ipsec. Get the
866 * rq from associated conf, or make
867 * RTE_FLOW_ACTION_TYPE_QUEUE compulsory with this
869 * Currently, rq = 0 is assumed.
871 req_act |= OTX2_FLOW_ACT_SEC;
875 errmsg = "Unsupported action specified";
881 /* Check if actions specified are compatible */
883 /* Only DROP/COUNT is supported */
884 if (!(req_act & OTX2_FLOW_ACT_DROP)) {
885 errmsg = "DROP is required action for egress";
888 } else if (req_act & ~(OTX2_FLOW_ACT_DROP |
889 OTX2_FLOW_ACT_COUNT)) {
890 errmsg = "Unsupported action specified";
894 flow->npc_action = NIX_TX_ACTIONOP_DROP;
898 /* We have already verified the attr, this is ingress.
899 * - Exactly one terminating action is supported
900 * - Exactly one of MARK or FLAG is supported
901 * - If terminating action is DROP, only count is valid.
903 sel_act = req_act & OTX2_FLOW_ACT_TERM;
904 if ((sel_act & (sel_act - 1)) != 0) {
905 errmsg = "Only one terminating action supported";
910 if (req_act & OTX2_FLOW_ACT_DROP) {
911 sel_act = req_act & ~OTX2_FLOW_ACT_COUNT;
912 if ((sel_act & (sel_act - 1)) != 0) {
913 errmsg = "Only COUNT action is supported "
914 "with DROP ingress action";
920 if ((req_act & (OTX2_FLOW_ACT_FLAG | OTX2_FLOW_ACT_MARK))
921 == (OTX2_FLOW_ACT_FLAG | OTX2_FLOW_ACT_MARK)) {
922 errmsg = "Only one of FLAG or MARK action is supported";
927 /* Set NIX_RX_ACTIONOP */
928 if (req_act & (OTX2_FLOW_ACT_PF | OTX2_FLOW_ACT_VF)) {
929 flow->npc_action = NIX_RX_ACTIONOP_UCAST;
930 if (req_act & OTX2_FLOW_ACT_QUEUE)
931 flow->npc_action |= (uint64_t)rq << 20;
932 } else if (req_act & OTX2_FLOW_ACT_DROP) {
933 flow->npc_action = NIX_RX_ACTIONOP_DROP;
934 } else if (req_act & OTX2_FLOW_ACT_QUEUE) {
935 flow->npc_action = NIX_RX_ACTIONOP_UCAST;
936 flow->npc_action |= (uint64_t)rq << 20;
937 } else if (req_act & OTX2_FLOW_ACT_RSS) {
938 /* When user added a rule for rss, first we will add the
939 *rule in MCAM and then update the action, once if we have
940 *FLOW_KEY_ALG index. So, till we update the action with
941 *flow_key_alg index, set the action to drop.
943 if (dev->data->dev_conf.rxmode.mq_mode == ETH_MQ_RX_RSS)
944 flow->npc_action = NIX_RX_ACTIONOP_DROP;
946 flow->npc_action = NIX_RX_ACTIONOP_UCAST;
947 } else if (req_act & OTX2_FLOW_ACT_SEC) {
948 flow->npc_action = NIX_RX_ACTIONOP_UCAST_IPSEC;
949 flow->npc_action |= (uint64_t)rq << 20;
950 } else if (req_act & (OTX2_FLOW_ACT_FLAG | OTX2_FLOW_ACT_MARK)) {
951 flow->npc_action = NIX_RX_ACTIONOP_UCAST;
952 } else if (req_act & OTX2_FLOW_ACT_COUNT) {
953 /* Keep OTX2_FLOW_ACT_COUNT always at the end
954 * This is default action, when user specify only
957 flow->npc_action = NIX_RX_ACTIONOP_UCAST;
959 /* Should never reach here */
960 errmsg = "Invalid action specified";
966 flow->npc_action |= (uint64_t)mark << 40;
968 if (rte_atomic32_read(&npc->mark_actions) == 1) {
969 hw->rx_offload_flags |=
970 NIX_RX_OFFLOAD_MARK_UPDATE_F;
971 otx2_eth_set_rx_function(dev);
975 /* Ideally AF must ensure that correct pf_func is set */
976 flow->npc_action |= (uint64_t)pf_func << 4;
981 rte_flow_error_set(error, errcode,
982 RTE_FLOW_ERROR_TYPE_ACTION_NUM, NULL,