LCOV - code coverage report
Current view: top level - drivers/net/dpaa2 - dpaa2_flow.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 0 1655 0.0 %
Date: 2024-01-22 15:35:40 Functions: 0 38 0.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 1233 0.0 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright 2018-2021 NXP
       3                 :            :  */
       4                 :            : 
       5                 :            : #include <sys/queue.h>
       6                 :            : #include <stdio.h>
       7                 :            : #include <errno.h>
       8                 :            : #include <stdint.h>
       9                 :            : #include <string.h>
      10                 :            : #include <unistd.h>
      11                 :            : #include <stdarg.h>
      12                 :            : 
      13                 :            : #include <rte_ethdev.h>
      14                 :            : #include <rte_log.h>
      15                 :            : #include <rte_malloc.h>
      16                 :            : #include <rte_flow_driver.h>
      17                 :            : #include <rte_tailq.h>
      18                 :            : 
      19                 :            : #include <fsl_dpni.h>
      20                 :            : #include <fsl_dpkg.h>
      21                 :            : 
      22                 :            : #include <dpaa2_ethdev.h>
      23                 :            : #include <dpaa2_pmd_logs.h>
      24                 :            : 
      25                 :            : /* Workaround to discriminate the UDP/TCP/SCTP
      26                 :            :  * with next protocol of l3.
      27                 :            :  * MC/WRIOP are not able to identify
      28                 :            :  * the l4 protocol with l4 ports.
      29                 :            :  */
      30                 :            : int mc_l4_port_identification;
      31                 :            : 
      32                 :            : static char *dpaa2_flow_control_log;
      33                 :            : static uint16_t dpaa2_flow_miss_flow_id =
      34                 :            :         DPNI_FS_MISS_DROP;
      35                 :            : 
      36                 :            : #define FIXED_ENTRY_SIZE DPNI_MAX_KEY_SIZE
      37                 :            : 
      38                 :            : enum flow_rule_ipaddr_type {
      39                 :            :         FLOW_NONE_IPADDR,
      40                 :            :         FLOW_IPV4_ADDR,
      41                 :            :         FLOW_IPV6_ADDR
      42                 :            : };
      43                 :            : 
      44                 :            : struct flow_rule_ipaddr {
      45                 :            :         enum flow_rule_ipaddr_type ipaddr_type;
      46                 :            :         int qos_ipsrc_offset;
      47                 :            :         int qos_ipdst_offset;
      48                 :            :         int fs_ipsrc_offset;
      49                 :            :         int fs_ipdst_offset;
      50                 :            : };
      51                 :            : 
      52                 :            : struct rte_flow {
      53                 :            :         LIST_ENTRY(rte_flow) next; /**< Pointer to the next flow structure. */
      54                 :            :         struct dpni_rule_cfg qos_rule;
      55                 :            :         struct dpni_rule_cfg fs_rule;
      56                 :            :         uint8_t qos_real_key_size;
      57                 :            :         uint8_t fs_real_key_size;
      58                 :            :         uint8_t tc_id; /** Traffic Class ID. */
      59                 :            :         uint8_t tc_index; /** index within this Traffic Class. */
      60                 :            :         enum rte_flow_action_type action;
      61                 :            :         /* Special for IP address to specify the offset
      62                 :            :          * in key/mask.
      63                 :            :          */
      64                 :            :         struct flow_rule_ipaddr ipaddr_rule;
      65                 :            :         struct dpni_fs_action_cfg action_cfg;
      66                 :            : };
      67                 :            : 
      68                 :            : static const
      69                 :            : enum rte_flow_item_type dpaa2_supported_pattern_type[] = {
      70                 :            :         RTE_FLOW_ITEM_TYPE_END,
      71                 :            :         RTE_FLOW_ITEM_TYPE_ETH,
      72                 :            :         RTE_FLOW_ITEM_TYPE_VLAN,
      73                 :            :         RTE_FLOW_ITEM_TYPE_IPV4,
      74                 :            :         RTE_FLOW_ITEM_TYPE_IPV6,
      75                 :            :         RTE_FLOW_ITEM_TYPE_ICMP,
      76                 :            :         RTE_FLOW_ITEM_TYPE_UDP,
      77                 :            :         RTE_FLOW_ITEM_TYPE_TCP,
      78                 :            :         RTE_FLOW_ITEM_TYPE_SCTP,
      79                 :            :         RTE_FLOW_ITEM_TYPE_GRE,
      80                 :            : };
      81                 :            : 
      82                 :            : static const
      83                 :            : enum rte_flow_action_type dpaa2_supported_action_type[] = {
      84                 :            :         RTE_FLOW_ACTION_TYPE_END,
      85                 :            :         RTE_FLOW_ACTION_TYPE_QUEUE,
      86                 :            :         RTE_FLOW_ACTION_TYPE_PORT_ID,
      87                 :            :         RTE_FLOW_ACTION_TYPE_REPRESENTED_PORT,
      88                 :            :         RTE_FLOW_ACTION_TYPE_RSS
      89                 :            : };
      90                 :            : 
      91                 :            : static const
      92                 :            : enum rte_flow_action_type dpaa2_supported_fs_action_type[] = {
      93                 :            :         RTE_FLOW_ACTION_TYPE_QUEUE,
      94                 :            :         RTE_FLOW_ACTION_TYPE_PORT_ID,
      95                 :            :         RTE_FLOW_ACTION_TYPE_REPRESENTED_PORT,
      96                 :            : };
      97                 :            : 
      98                 :            : /* Max of enum rte_flow_item_type + 1, for both IPv4 and IPv6*/
      99                 :            : #define DPAA2_FLOW_ITEM_TYPE_GENERIC_IP (RTE_FLOW_ITEM_TYPE_META + 1)
     100                 :            : 
     101                 :            : #ifndef __cplusplus
     102                 :            : static const struct rte_flow_item_eth dpaa2_flow_item_eth_mask = {
     103                 :            :         .hdr.dst_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff",
     104                 :            :         .hdr.src_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff",
     105                 :            :         .hdr.ether_type = RTE_BE16(0xffff),
     106                 :            : };
     107                 :            : 
     108                 :            : static const struct rte_flow_item_vlan dpaa2_flow_item_vlan_mask = {
     109                 :            :         .hdr.vlan_tci = RTE_BE16(0xffff),
     110                 :            : };
     111                 :            : 
     112                 :            : static const struct rte_flow_item_ipv4 dpaa2_flow_item_ipv4_mask = {
     113                 :            :         .hdr.src_addr = RTE_BE32(0xffffffff),
     114                 :            :         .hdr.dst_addr = RTE_BE32(0xffffffff),
     115                 :            :         .hdr.next_proto_id = 0xff,
     116                 :            : };
     117                 :            : 
     118                 :            : static const struct rte_flow_item_ipv6 dpaa2_flow_item_ipv6_mask = {
     119                 :            :         .hdr = {
     120                 :            :                 .src_addr =
     121                 :            :                         "\xff\xff\xff\xff\xff\xff\xff\xff"
     122                 :            :                         "\xff\xff\xff\xff\xff\xff\xff\xff",
     123                 :            :                 .dst_addr =
     124                 :            :                         "\xff\xff\xff\xff\xff\xff\xff\xff"
     125                 :            :                         "\xff\xff\xff\xff\xff\xff\xff\xff",
     126                 :            :                 .proto = 0xff
     127                 :            :         },
     128                 :            : };
     129                 :            : 
     130                 :            : static const struct rte_flow_item_icmp dpaa2_flow_item_icmp_mask = {
     131                 :            :         .hdr.icmp_type = 0xff,
     132                 :            :         .hdr.icmp_code = 0xff,
     133                 :            : };
     134                 :            : 
     135                 :            : static const struct rte_flow_item_udp dpaa2_flow_item_udp_mask = {
     136                 :            :         .hdr = {
     137                 :            :                 .src_port = RTE_BE16(0xffff),
     138                 :            :                 .dst_port = RTE_BE16(0xffff),
     139                 :            :         },
     140                 :            : };
     141                 :            : 
     142                 :            : static const struct rte_flow_item_tcp dpaa2_flow_item_tcp_mask = {
     143                 :            :         .hdr = {
     144                 :            :                 .src_port = RTE_BE16(0xffff),
     145                 :            :                 .dst_port = RTE_BE16(0xffff),
     146                 :            :         },
     147                 :            : };
     148                 :            : 
     149                 :            : static const struct rte_flow_item_sctp dpaa2_flow_item_sctp_mask = {
     150                 :            :         .hdr = {
     151                 :            :                 .src_port = RTE_BE16(0xffff),
     152                 :            :                 .dst_port = RTE_BE16(0xffff),
     153                 :            :         },
     154                 :            : };
     155                 :            : 
     156                 :            : static const struct rte_flow_item_gre dpaa2_flow_item_gre_mask = {
     157                 :            :         .protocol = RTE_BE16(0xffff),
     158                 :            : };
     159                 :            : 
     160                 :            : #endif
     161                 :            : 
     162                 :          0 : static inline void dpaa2_prot_field_string(
     163                 :            :         enum net_prot prot, uint32_t field,
     164                 :            :         char *string)
     165                 :            : {
     166         [ #  # ]:          0 :         if (!dpaa2_flow_control_log)
     167                 :            :                 return;
     168                 :            : 
     169                 :            :         if (prot == NET_PROT_ETH) {
     170                 :            :                 strcpy(string, "eth");
     171         [ #  # ]:          0 :                 if (field == NH_FLD_ETH_DA)
     172                 :            :                         strcat(string, ".dst");
     173         [ #  # ]:          0 :                 else if (field == NH_FLD_ETH_SA)
     174                 :            :                         strcat(string, ".src");
     175         [ #  # ]:          0 :                 else if (field == NH_FLD_ETH_TYPE)
     176                 :            :                         strcat(string, ".type");
     177                 :            :                 else
     178                 :            :                         strcat(string, ".unknown field");
     179                 :            :         } else if (prot == NET_PROT_VLAN) {
     180                 :            :                 strcpy(string, "vlan");
     181         [ #  # ]:          0 :                 if (field == NH_FLD_VLAN_TCI)
     182                 :            :                         strcat(string, ".tci");
     183                 :            :                 else
     184                 :            :                         strcat(string, ".unknown field");
     185                 :            :         } else if (prot == NET_PROT_IP) {
     186                 :            :                 strcpy(string, "ip");
     187         [ #  # ]:          0 :                 if (field == NH_FLD_IP_SRC)
     188                 :            :                         strcat(string, ".src");
     189         [ #  # ]:          0 :                 else if (field == NH_FLD_IP_DST)
     190                 :            :                         strcat(string, ".dst");
     191         [ #  # ]:          0 :                 else if (field == NH_FLD_IP_PROTO)
     192                 :            :                         strcat(string, ".proto");
     193                 :            :                 else
     194                 :            :                         strcat(string, ".unknown field");
     195                 :            :         } else if (prot == NET_PROT_TCP) {
     196                 :            :                 strcpy(string, "tcp");
     197         [ #  # ]:          0 :                 if (field == NH_FLD_TCP_PORT_SRC)
     198                 :            :                         strcat(string, ".src");
     199         [ #  # ]:          0 :                 else if (field == NH_FLD_TCP_PORT_DST)
     200                 :            :                         strcat(string, ".dst");
     201                 :            :                 else
     202                 :            :                         strcat(string, ".unknown field");
     203                 :            :         } else if (prot == NET_PROT_UDP) {
     204                 :            :                 strcpy(string, "udp");
     205         [ #  # ]:          0 :                 if (field == NH_FLD_UDP_PORT_SRC)
     206                 :            :                         strcat(string, ".src");
     207         [ #  # ]:          0 :                 else if (field == NH_FLD_UDP_PORT_DST)
     208                 :            :                         strcat(string, ".dst");
     209                 :            :                 else
     210                 :            :                         strcat(string, ".unknown field");
     211                 :            :         } else if (prot == NET_PROT_ICMP) {
     212                 :            :                 strcpy(string, "icmp");
     213         [ #  # ]:          0 :                 if (field == NH_FLD_ICMP_TYPE)
     214                 :            :                         strcat(string, ".type");
     215         [ #  # ]:          0 :                 else if (field == NH_FLD_ICMP_CODE)
     216                 :            :                         strcat(string, ".code");
     217                 :            :                 else
     218                 :            :                         strcat(string, ".unknown field");
     219                 :            :         } else if (prot == NET_PROT_SCTP) {
     220                 :            :                 strcpy(string, "sctp");
     221         [ #  # ]:          0 :                 if (field == NH_FLD_SCTP_PORT_SRC)
     222                 :            :                         strcat(string, ".src");
     223         [ #  # ]:          0 :                 else if (field == NH_FLD_SCTP_PORT_DST)
     224                 :            :                         strcat(string, ".dst");
     225                 :            :                 else
     226                 :            :                         strcat(string, ".unknown field");
     227                 :            :         } else if (prot == NET_PROT_GRE) {
     228                 :            :                 strcpy(string, "gre");
     229         [ #  # ]:          0 :                 if (field == NH_FLD_GRE_TYPE)
     230                 :            :                         strcat(string, ".type");
     231                 :            :                 else
     232                 :            :                         strcat(string, ".unknown field");
     233                 :            :         } else {
     234                 :            :                 strcpy(string, "unknown protocol");
     235                 :            :         }
     236                 :            : }
     237                 :            : 
     238                 :          0 : static inline void dpaa2_flow_qos_table_extracts_log(
     239                 :            :         const struct dpaa2_dev_priv *priv)
     240                 :            : {
     241                 :            :         int idx;
     242                 :            :         char string[32];
     243                 :            : 
     244         [ #  # ]:          0 :         if (!dpaa2_flow_control_log)
     245                 :          0 :                 return;
     246                 :            : 
     247                 :          0 :         printf("Setup QoS table: number of extracts: %d\r\n",
     248                 :          0 :                         priv->extract.qos_key_extract.dpkg.num_extracts);
     249         [ #  # ]:          0 :         for (idx = 0; idx < priv->extract.qos_key_extract.dpkg.num_extracts;
     250                 :            :                 idx++) {
     251                 :          0 :                 dpaa2_prot_field_string(priv->extract.qos_key_extract.dpkg
     252                 :          0 :                         .extracts[idx].extract.from_hdr.prot,
     253                 :            :                         priv->extract.qos_key_extract.dpkg.extracts[idx]
     254                 :          0 :                         .extract.from_hdr.field,
     255                 :            :                         string);
     256                 :            :                 printf("%s", string);
     257         [ #  # ]:          0 :                 if ((idx + 1) < priv->extract.qos_key_extract.dpkg.num_extracts)
     258                 :            :                         printf(" / ");
     259                 :            :         }
     260                 :            :         printf("\r\n");
     261                 :            : }
     262                 :            : 
     263                 :          0 : static inline void dpaa2_flow_fs_table_extracts_log(
     264                 :            :         const struct dpaa2_dev_priv *priv, int tc_id)
     265                 :            : {
     266                 :            :         int idx;
     267                 :            :         char string[32];
     268                 :            : 
     269         [ #  # ]:          0 :         if (!dpaa2_flow_control_log)
     270                 :          0 :                 return;
     271                 :            : 
     272                 :          0 :         printf("Setup FS table: number of extracts of TC[%d]: %d\r\n",
     273                 :            :                         tc_id, priv->extract.tc_key_extract[tc_id]
     274                 :          0 :                         .dpkg.num_extracts);
     275                 :          0 :         for (idx = 0; idx < priv->extract.tc_key_extract[tc_id]
     276         [ #  # ]:          0 :                 .dpkg.num_extracts; idx++) {
     277                 :          0 :                 dpaa2_prot_field_string(priv->extract.tc_key_extract[tc_id]
     278                 :          0 :                         .dpkg.extracts[idx].extract.from_hdr.prot,
     279                 :            :                         priv->extract.tc_key_extract[tc_id].dpkg.extracts[idx]
     280                 :          0 :                         .extract.from_hdr.field,
     281                 :            :                         string);
     282                 :            :                 printf("%s", string);
     283                 :          0 :                 if ((idx + 1) < priv->extract.tc_key_extract[tc_id]
     284         [ #  # ]:          0 :                         .dpkg.num_extracts)
     285                 :            :                         printf(" / ");
     286                 :            :         }
     287                 :            :         printf("\r\n");
     288                 :            : }
     289                 :            : 
     290                 :          0 : static inline void dpaa2_flow_qos_entry_log(
     291                 :            :         const char *log_info, const struct rte_flow *flow, int qos_index)
     292                 :            : {
     293                 :            :         int idx;
     294                 :            :         uint8_t *key, *mask;
     295                 :            : 
     296         [ #  # ]:          0 :         if (!dpaa2_flow_control_log)
     297                 :            :                 return;
     298                 :            : 
     299                 :          0 :         printf("\r\n%s QoS entry[%d] for TC[%d], extracts size is %d\r\n",
     300                 :          0 :                 log_info, qos_index, flow->tc_id, flow->qos_real_key_size);
     301                 :            : 
     302                 :          0 :         key = (uint8_t *)(size_t)flow->qos_rule.key_iova;
     303                 :          0 :         mask = (uint8_t *)(size_t)flow->qos_rule.mask_iova;
     304                 :            : 
     305                 :            :         printf("key:\r\n");
     306         [ #  # ]:          0 :         for (idx = 0; idx < flow->qos_real_key_size; idx++)
     307                 :          0 :                 printf("%02x ", key[idx]);
     308                 :            : 
     309                 :            :         printf("\r\nmask:\r\n");
     310         [ #  # ]:          0 :         for (idx = 0; idx < flow->qos_real_key_size; idx++)
     311                 :          0 :                 printf("%02x ", mask[idx]);
     312                 :            : 
     313                 :            :         printf("\r\n%s QoS ipsrc: %d, ipdst: %d\r\n", log_info,
     314                 :          0 :                 flow->ipaddr_rule.qos_ipsrc_offset,
     315                 :          0 :                 flow->ipaddr_rule.qos_ipdst_offset);
     316                 :            : }
     317                 :            : 
     318                 :          0 : static inline void dpaa2_flow_fs_entry_log(
     319                 :            :         const char *log_info, const struct rte_flow *flow)
     320                 :            : {
     321                 :            :         int idx;
     322                 :            :         uint8_t *key, *mask;
     323                 :            : 
     324         [ #  # ]:          0 :         if (!dpaa2_flow_control_log)
     325                 :            :                 return;
     326                 :            : 
     327                 :          0 :         printf("\r\n%s FS/TC entry[%d] of TC[%d], extracts size is %d\r\n",
     328                 :          0 :                 log_info, flow->tc_index, flow->tc_id, flow->fs_real_key_size);
     329                 :            : 
     330                 :          0 :         key = (uint8_t *)(size_t)flow->fs_rule.key_iova;
     331                 :          0 :         mask = (uint8_t *)(size_t)flow->fs_rule.mask_iova;
     332                 :            : 
     333                 :            :         printf("key:\r\n");
     334         [ #  # ]:          0 :         for (idx = 0; idx < flow->fs_real_key_size; idx++)
     335                 :          0 :                 printf("%02x ", key[idx]);
     336                 :            : 
     337                 :            :         printf("\r\nmask:\r\n");
     338         [ #  # ]:          0 :         for (idx = 0; idx < flow->fs_real_key_size; idx++)
     339                 :          0 :                 printf("%02x ", mask[idx]);
     340                 :            : 
     341                 :            :         printf("\r\n%s FS ipsrc: %d, ipdst: %d\r\n", log_info,
     342                 :          0 :                 flow->ipaddr_rule.fs_ipsrc_offset,
     343                 :          0 :                 flow->ipaddr_rule.fs_ipdst_offset);
     344                 :            : }
     345                 :            : 
     346                 :            : static inline void dpaa2_flow_extract_key_set(
     347                 :            :         struct dpaa2_key_info *key_info, int index, uint8_t size)
     348                 :            : {
     349                 :          0 :         key_info->key_size[index] = size;
     350   [ #  #  #  # ]:          0 :         if (index > 0) {
     351                 :          0 :                 key_info->key_offset[index] =
     352                 :          0 :                         key_info->key_offset[index - 1] +
     353                 :          0 :                         key_info->key_size[index - 1];
     354                 :            :         } else {
     355                 :          0 :                 key_info->key_offset[index] = 0;
     356                 :            :         }
     357                 :          0 :         key_info->key_total_size += size;
     358                 :          0 : }
     359                 :            : 
     360                 :          0 : static int dpaa2_flow_extract_add(
     361                 :            :         struct dpaa2_key_extract *key_extract,
     362                 :            :         enum net_prot prot,
     363                 :            :         uint32_t field, uint8_t field_size)
     364                 :            : {
     365                 :            :         int index, ip_src = -1, ip_dst = -1;
     366                 :            :         struct dpkg_profile_cfg *dpkg = &key_extract->dpkg;
     367                 :            :         struct dpaa2_key_info *key_info = &key_extract->key_info;
     368                 :            : 
     369         [ #  # ]:          0 :         if (dpkg->num_extracts >=
     370                 :            :                 DPKG_MAX_NUM_OF_EXTRACTS) {
     371                 :          0 :                 DPAA2_PMD_WARN("Number of extracts overflows");
     372                 :          0 :                 return -1;
     373                 :            :         }
     374                 :            :         /* Before reorder, the IP SRC and IP DST are already last
     375                 :            :          * extract(s).
     376                 :            :          */
     377         [ #  # ]:          0 :         for (index = 0; index < dpkg->num_extracts; index++) {
     378         [ #  # ]:          0 :                 if (dpkg->extracts[index].extract.from_hdr.prot ==
     379                 :            :                         NET_PROT_IP) {
     380         [ #  # ]:          0 :                         if (dpkg->extracts[index].extract.from_hdr.field ==
     381                 :            :                                 NH_FLD_IP_SRC) {
     382                 :            :                                 ip_src = index;
     383                 :            :                         }
     384         [ #  # ]:          0 :                         if (dpkg->extracts[index].extract.from_hdr.field ==
     385                 :            :                                 NH_FLD_IP_DST) {
     386                 :            :                                 ip_dst = index;
     387                 :            :                         }
     388                 :            :                 }
     389                 :            :         }
     390                 :            : 
     391                 :            :         if (ip_src >= 0)
     392                 :            :                 RTE_ASSERT((ip_src + 2) >= dpkg->num_extracts);
     393                 :            : 
     394                 :            :         if (ip_dst >= 0)
     395                 :            :                 RTE_ASSERT((ip_dst + 2) >= dpkg->num_extracts);
     396                 :            : 
     397         [ #  # ]:          0 :         if (prot == NET_PROT_IP &&
     398                 :          0 :                 (field == NH_FLD_IP_SRC ||
     399         [ #  # ]:          0 :                 field == NH_FLD_IP_DST)) {
     400                 :            :                 index = dpkg->num_extracts;
     401                 :            :         } else {
     402         [ #  # ]:          0 :                 if (ip_src >= 0 && ip_dst >= 0)
     403                 :          0 :                         index = dpkg->num_extracts - 2;
     404         [ #  # ]:          0 :                 else if (ip_src >= 0 || ip_dst >= 0)
     405                 :          0 :                         index = dpkg->num_extracts - 1;
     406                 :            :                 else
     407                 :            :                         index = dpkg->num_extracts;
     408                 :            :         }
     409                 :            : 
     410                 :          0 :         dpkg->extracts[index].type = DPKG_EXTRACT_FROM_HDR;
     411                 :          0 :         dpkg->extracts[index].extract.from_hdr.type = DPKG_FULL_FIELD;
     412                 :          0 :         dpkg->extracts[index].extract.from_hdr.prot = prot;
     413                 :          0 :         dpkg->extracts[index].extract.from_hdr.field = field;
     414         [ #  # ]:          0 :         if (prot == NET_PROT_IP &&
     415                 :          0 :                 (field == NH_FLD_IP_SRC ||
     416         [ #  # ]:          0 :                 field == NH_FLD_IP_DST)) {
     417                 :            :                 dpaa2_flow_extract_key_set(key_info, index, 0);
     418                 :            :         } else {
     419                 :            :                 dpaa2_flow_extract_key_set(key_info, index, field_size);
     420                 :            :         }
     421                 :            : 
     422         [ #  # ]:          0 :         if (prot == NET_PROT_IP) {
     423         [ #  # ]:          0 :                 if (field == NH_FLD_IP_SRC) {
     424         [ #  # ]:          0 :                         if (key_info->ipv4_dst_offset >= 0) {
     425                 :          0 :                                 key_info->ipv4_src_offset =
     426                 :          0 :                                         key_info->ipv4_dst_offset +
     427                 :            :                                         NH_FLD_IPV4_ADDR_SIZE;
     428                 :            :                         } else {
     429                 :          0 :                                 key_info->ipv4_src_offset =
     430                 :          0 :                                         key_info->key_offset[index - 1] +
     431                 :          0 :                                                 key_info->key_size[index - 1];
     432                 :            :                         }
     433         [ #  # ]:          0 :                         if (key_info->ipv6_dst_offset >= 0) {
     434                 :          0 :                                 key_info->ipv6_src_offset =
     435                 :          0 :                                         key_info->ipv6_dst_offset +
     436                 :            :                                         NH_FLD_IPV6_ADDR_SIZE;
     437                 :            :                         } else {
     438                 :          0 :                                 key_info->ipv6_src_offset =
     439                 :          0 :                                         key_info->key_offset[index - 1] +
     440                 :          0 :                                                 key_info->key_size[index - 1];
     441                 :            :                         }
     442         [ #  # ]:          0 :                 } else if (field == NH_FLD_IP_DST) {
     443         [ #  # ]:          0 :                         if (key_info->ipv4_src_offset >= 0) {
     444                 :          0 :                                 key_info->ipv4_dst_offset =
     445                 :          0 :                                         key_info->ipv4_src_offset +
     446                 :            :                                         NH_FLD_IPV4_ADDR_SIZE;
     447                 :            :                         } else {
     448                 :          0 :                                 key_info->ipv4_dst_offset =
     449                 :          0 :                                         key_info->key_offset[index - 1] +
     450                 :          0 :                                                 key_info->key_size[index - 1];
     451                 :            :                         }
     452         [ #  # ]:          0 :                         if (key_info->ipv6_src_offset >= 0) {
     453                 :          0 :                                 key_info->ipv6_dst_offset =
     454                 :          0 :                                         key_info->ipv6_src_offset +
     455                 :            :                                         NH_FLD_IPV6_ADDR_SIZE;
     456                 :            :                         } else {
     457                 :          0 :                                 key_info->ipv6_dst_offset =
     458                 :          0 :                                         key_info->key_offset[index - 1] +
     459                 :          0 :                                                 key_info->key_size[index - 1];
     460                 :            :                         }
     461                 :            :                 }
     462                 :            :         }
     463                 :            : 
     464         [ #  # ]:          0 :         if (index == dpkg->num_extracts) {
     465                 :          0 :                 dpkg->num_extracts++;
     466                 :          0 :                 return 0;
     467                 :            :         }
     468                 :            : 
     469         [ #  # ]:          0 :         if (ip_src >= 0) {
     470                 :          0 :                 ip_src++;
     471                 :          0 :                 dpkg->extracts[ip_src].type =
     472                 :            :                         DPKG_EXTRACT_FROM_HDR;
     473                 :          0 :                 dpkg->extracts[ip_src].extract.from_hdr.type =
     474                 :            :                         DPKG_FULL_FIELD;
     475                 :          0 :                 dpkg->extracts[ip_src].extract.from_hdr.prot =
     476                 :            :                         NET_PROT_IP;
     477                 :          0 :                 dpkg->extracts[ip_src].extract.from_hdr.field =
     478                 :            :                         NH_FLD_IP_SRC;
     479                 :            :                 dpaa2_flow_extract_key_set(key_info, ip_src, 0);
     480                 :          0 :                 key_info->ipv4_src_offset += field_size;
     481                 :          0 :                 key_info->ipv6_src_offset += field_size;
     482                 :            :         }
     483         [ #  # ]:          0 :         if (ip_dst >= 0) {
     484                 :          0 :                 ip_dst++;
     485                 :          0 :                 dpkg->extracts[ip_dst].type =
     486                 :            :                         DPKG_EXTRACT_FROM_HDR;
     487                 :          0 :                 dpkg->extracts[ip_dst].extract.from_hdr.type =
     488                 :            :                         DPKG_FULL_FIELD;
     489                 :          0 :                 dpkg->extracts[ip_dst].extract.from_hdr.prot =
     490                 :            :                         NET_PROT_IP;
     491                 :          0 :                 dpkg->extracts[ip_dst].extract.from_hdr.field =
     492                 :            :                         NH_FLD_IP_DST;
     493                 :            :                 dpaa2_flow_extract_key_set(key_info, ip_dst, 0);
     494                 :          0 :                 key_info->ipv4_dst_offset += field_size;
     495                 :          0 :                 key_info->ipv6_dst_offset += field_size;
     496                 :            :         }
     497                 :            : 
     498                 :          0 :         dpkg->num_extracts++;
     499                 :            : 
     500                 :          0 :         return 0;
     501                 :            : }
     502                 :            : 
     503                 :          0 : static int dpaa2_flow_extract_add_raw(struct dpaa2_key_extract *key_extract,
     504                 :            :                                       int size)
     505                 :            : {
     506                 :            :         struct dpkg_profile_cfg *dpkg = &key_extract->dpkg;
     507                 :            :         struct dpaa2_key_info *key_info = &key_extract->key_info;
     508                 :            :         int last_extract_size, index;
     509                 :            : 
     510   [ #  #  #  # ]:          0 :         if (dpkg->num_extracts != 0 && dpkg->extracts[0].type !=
     511                 :            :             DPKG_EXTRACT_FROM_DATA) {
     512                 :          0 :                 DPAA2_PMD_WARN("RAW extract cannot be combined with others");
     513                 :          0 :                 return -1;
     514                 :            :         }
     515                 :            : 
     516                 :          0 :         last_extract_size = (size % DPAA2_FLOW_MAX_KEY_SIZE);
     517                 :          0 :         dpkg->num_extracts = (size / DPAA2_FLOW_MAX_KEY_SIZE);
     518         [ #  # ]:          0 :         if (last_extract_size)
     519                 :          0 :                 dpkg->num_extracts++;
     520                 :            :         else
     521                 :            :                 last_extract_size = DPAA2_FLOW_MAX_KEY_SIZE;
     522                 :            : 
     523         [ #  # ]:          0 :         for (index = 0; index < dpkg->num_extracts; index++) {
     524                 :          0 :                 dpkg->extracts[index].type = DPKG_EXTRACT_FROM_DATA;
     525         [ #  # ]:          0 :                 if (index == dpkg->num_extracts - 1)
     526                 :          0 :                         dpkg->extracts[index].extract.from_data.size =
     527                 :            :                                 last_extract_size;
     528                 :            :                 else
     529                 :          0 :                         dpkg->extracts[index].extract.from_data.size =
     530                 :            :                                 DPAA2_FLOW_MAX_KEY_SIZE;
     531                 :          0 :                 dpkg->extracts[index].extract.from_data.offset =
     532                 :            :                         DPAA2_FLOW_MAX_KEY_SIZE * index;
     533                 :            :         }
     534                 :            : 
     535                 :          0 :         key_info->key_total_size = size;
     536                 :          0 :         return 0;
     537                 :            : }
     538                 :            : 
     539                 :            : /* Protocol discrimination.
     540                 :            :  * Discriminate IPv4/IPv6/vLan by Eth type.
     541                 :            :  * Discriminate UDP/TCP/ICMP by next proto of IP.
     542                 :            :  */
     543                 :            : static inline int
     544                 :            : dpaa2_flow_proto_discrimination_extract(
     545                 :            :         struct dpaa2_key_extract *key_extract,
     546                 :            :         enum rte_flow_item_type type)
     547                 :            : {
     548                 :            :         if (type == RTE_FLOW_ITEM_TYPE_ETH) {
     549                 :          0 :                 return dpaa2_flow_extract_add(
     550                 :            :                                 key_extract, NET_PROT_ETH,
     551                 :            :                                 NH_FLD_ETH_TYPE,
     552                 :            :                                 sizeof(rte_be16_t));
     553                 :            :         } else if (type == (enum rte_flow_item_type)
     554                 :            :                 DPAA2_FLOW_ITEM_TYPE_GENERIC_IP) {
     555                 :          0 :                 return dpaa2_flow_extract_add(
     556                 :            :                                 key_extract, NET_PROT_IP,
     557                 :            :                                 NH_FLD_IP_PROTO,
     558                 :            :                                 NH_FLD_IP_PROTO_SIZE);
     559                 :            :         }
     560                 :            : 
     561                 :            :         return -1;
     562                 :            : }
     563                 :            : 
     564                 :            : static inline int dpaa2_flow_extract_search(
     565                 :            :         struct dpkg_profile_cfg *dpkg,
     566                 :            :         enum net_prot prot, uint32_t field)
     567                 :            : {
     568                 :            :         int i;
     569                 :            : 
     570   [ #  #  #  #  :          0 :         for (i = 0; i < dpkg->num_extracts; i++) {
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     571   [ #  #  #  #  :          0 :                 if (dpkg->extracts[i].extract.from_hdr.prot == prot &&
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     572   [ #  #  #  #  :          0 :                         dpkg->extracts[i].extract.from_hdr.field == field) {
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     573                 :            :                         return i;
     574                 :            :                 }
     575                 :            :         }
     576                 :            : 
     577                 :            :         return -1;
     578                 :            : }
     579                 :            : 
     580                 :          0 : static inline int dpaa2_flow_extract_key_offset(
     581                 :            :         struct dpaa2_key_extract *key_extract,
     582                 :            :         enum net_prot prot, uint32_t field)
     583                 :            : {
     584                 :            :         int i;
     585                 :            :         struct dpkg_profile_cfg *dpkg = &key_extract->dpkg;
     586                 :            :         struct dpaa2_key_info *key_info = &key_extract->key_info;
     587                 :            : 
     588         [ #  # ]:          0 :         if (prot == NET_PROT_IPV4 ||
     589                 :            :                 prot == NET_PROT_IPV6)
     590                 :            :                 i = dpaa2_flow_extract_search(dpkg, NET_PROT_IP, field);
     591                 :            :         else
     592                 :            :                 i = dpaa2_flow_extract_search(dpkg, prot, field);
     593                 :            : 
     594         [ #  # ]:          0 :         if (i >= 0) {
     595         [ #  # ]:          0 :                 if (prot == NET_PROT_IPV4 && field == NH_FLD_IP_SRC)
     596                 :          0 :                         return key_info->ipv4_src_offset;
     597         [ #  # ]:          0 :                 else if (prot == NET_PROT_IPV4 && field == NH_FLD_IP_DST)
     598                 :          0 :                         return key_info->ipv4_dst_offset;
     599         [ #  # ]:          0 :                 else if (prot == NET_PROT_IPV6 && field == NH_FLD_IP_SRC)
     600                 :          0 :                         return key_info->ipv6_src_offset;
     601         [ #  # ]:          0 :                 else if (prot == NET_PROT_IPV6 && field == NH_FLD_IP_DST)
     602                 :          0 :                         return key_info->ipv6_dst_offset;
     603                 :            :                 else
     604                 :          0 :                         return key_info->key_offset[i];
     605                 :            :         } else {
     606                 :            :                 return -1;
     607                 :            :         }
     608                 :            : }
     609                 :            : 
     610                 :            : struct proto_discrimination {
     611                 :            :         enum rte_flow_item_type type;
     612                 :            :         union {
     613                 :            :                 rte_be16_t eth_type;
     614                 :            :                 uint8_t ip_proto;
     615                 :            :         };
     616                 :            : };
     617                 :            : 
     618                 :            : static int
     619                 :          0 : dpaa2_flow_proto_discrimination_rule(
     620                 :            :         struct dpaa2_dev_priv *priv, struct rte_flow *flow,
     621                 :            :         struct proto_discrimination proto, int group)
     622                 :            : {
     623                 :            :         enum net_prot prot;
     624                 :            :         uint32_t field;
     625                 :            :         int offset;
     626                 :            :         size_t key_iova;
     627                 :            :         size_t mask_iova;
     628                 :            :         rte_be16_t eth_type;
     629                 :            :         uint8_t ip_proto;
     630                 :            : 
     631         [ #  # ]:          0 :         if (proto.type == RTE_FLOW_ITEM_TYPE_ETH) {
     632                 :            :                 prot = NET_PROT_ETH;
     633                 :            :                 field = NH_FLD_ETH_TYPE;
     634         [ #  # ]:          0 :         } else if (proto.type == DPAA2_FLOW_ITEM_TYPE_GENERIC_IP) {
     635                 :            :                 prot = NET_PROT_IP;
     636                 :            :                 field = NH_FLD_IP_PROTO;
     637                 :            :         } else {
     638                 :          0 :                 DPAA2_PMD_ERR(
     639                 :            :                         "Only Eth and IP support to discriminate next proto.");
     640                 :          0 :                 return -1;
     641                 :            :         }
     642                 :            : 
     643                 :          0 :         offset = dpaa2_flow_extract_key_offset(&priv->extract.qos_key_extract,
     644                 :            :                         prot, field);
     645         [ #  # ]:          0 :         if (offset < 0) {
     646                 :          0 :                 DPAA2_PMD_ERR("QoS prot %d field %d extract failed",
     647                 :            :                                 prot, field);
     648                 :          0 :                 return -1;
     649                 :            :         }
     650                 :          0 :         key_iova = flow->qos_rule.key_iova + offset;
     651                 :          0 :         mask_iova = flow->qos_rule.mask_iova + offset;
     652         [ #  # ]:          0 :         if (proto.type == RTE_FLOW_ITEM_TYPE_ETH) {
     653                 :          0 :                 eth_type = proto.eth_type;
     654                 :          0 :                 memcpy((void *)key_iova, (const void *)(&eth_type),
     655                 :            :                         sizeof(rte_be16_t));
     656                 :          0 :                 eth_type = 0xffff;
     657                 :          0 :                 memcpy((void *)mask_iova, (const void *)(&eth_type),
     658                 :            :                         sizeof(rte_be16_t));
     659                 :            :         } else {
     660                 :          0 :                 ip_proto = proto.ip_proto;
     661                 :          0 :                 memcpy((void *)key_iova, (const void *)(&ip_proto),
     662                 :            :                         sizeof(uint8_t));
     663                 :          0 :                 ip_proto = 0xff;
     664                 :          0 :                 memcpy((void *)mask_iova, (const void *)(&ip_proto),
     665                 :            :                         sizeof(uint8_t));
     666                 :            :         }
     667                 :            : 
     668                 :          0 :         offset = dpaa2_flow_extract_key_offset(
     669                 :            :                         &priv->extract.tc_key_extract[group],
     670                 :            :                         prot, field);
     671         [ #  # ]:          0 :         if (offset < 0) {
     672                 :          0 :                 DPAA2_PMD_ERR("FS prot %d field %d extract failed",
     673                 :            :                                 prot, field);
     674                 :          0 :                 return -1;
     675                 :            :         }
     676                 :          0 :         key_iova = flow->fs_rule.key_iova + offset;
     677                 :          0 :         mask_iova = flow->fs_rule.mask_iova + offset;
     678                 :            : 
     679         [ #  # ]:          0 :         if (proto.type == RTE_FLOW_ITEM_TYPE_ETH) {
     680                 :          0 :                 eth_type = proto.eth_type;
     681                 :          0 :                 memcpy((void *)key_iova, (const void *)(&eth_type),
     682                 :            :                         sizeof(rte_be16_t));
     683                 :          0 :                 eth_type = 0xffff;
     684                 :          0 :                 memcpy((void *)mask_iova, (const void *)(&eth_type),
     685                 :            :                         sizeof(rte_be16_t));
     686                 :            :         } else {
     687                 :          0 :                 ip_proto = proto.ip_proto;
     688                 :          0 :                 memcpy((void *)key_iova, (const void *)(&ip_proto),
     689                 :            :                         sizeof(uint8_t));
     690                 :          0 :                 ip_proto = 0xff;
     691                 :          0 :                 memcpy((void *)mask_iova, (const void *)(&ip_proto),
     692                 :            :                         sizeof(uint8_t));
     693                 :            :         }
     694                 :            : 
     695                 :            :         return 0;
     696                 :            : }
     697                 :            : 
     698                 :            : static inline int
     699                 :          0 : dpaa2_flow_rule_data_set(
     700                 :            :         struct dpaa2_key_extract *key_extract,
     701                 :            :         struct dpni_rule_cfg *rule,
     702                 :            :         enum net_prot prot, uint32_t field,
     703                 :            :         const void *key, const void *mask, int size)
     704                 :            : {
     705                 :          0 :         int offset = dpaa2_flow_extract_key_offset(key_extract,
     706                 :            :                                 prot, field);
     707                 :            : 
     708         [ #  # ]:          0 :         if (offset < 0) {
     709                 :          0 :                 DPAA2_PMD_ERR("prot %d, field %d extract failed",
     710                 :            :                         prot, field);
     711                 :          0 :                 return -1;
     712                 :            :         }
     713                 :            : 
     714                 :          0 :         memcpy((void *)(size_t)(rule->key_iova + offset), key, size);
     715                 :          0 :         memcpy((void *)(size_t)(rule->mask_iova + offset), mask, size);
     716                 :            : 
     717                 :          0 :         return 0;
     718                 :            : }
     719                 :            : 
     720                 :            : static inline int
     721                 :          0 : dpaa2_flow_rule_data_set_raw(struct dpni_rule_cfg *rule,
     722                 :            :                              const void *key, const void *mask, int size)
     723                 :            : {
     724                 :            :         int offset = 0;
     725                 :            : 
     726                 :          0 :         memcpy((void *)(size_t)(rule->key_iova + offset), key, size);
     727                 :          0 :         memcpy((void *)(size_t)(rule->mask_iova + offset), mask, size);
     728                 :            : 
     729                 :          0 :         return 0;
     730                 :            : }
     731                 :            : 
     732                 :            : static inline int
     733                 :          0 : _dpaa2_flow_rule_move_ipaddr_tail(
     734                 :            :         struct dpaa2_key_extract *key_extract,
     735                 :            :         struct dpni_rule_cfg *rule, int src_offset,
     736                 :            :         uint32_t field, bool ipv4)
     737                 :            : {
     738                 :            :         size_t key_src;
     739                 :            :         size_t mask_src;
     740                 :            :         size_t key_dst;
     741                 :            :         size_t mask_dst;
     742                 :            :         int dst_offset, len;
     743                 :            :         enum net_prot prot;
     744                 :            :         char tmp[NH_FLD_IPV6_ADDR_SIZE];
     745                 :            : 
     746                 :          0 :         if (field != NH_FLD_IP_SRC &&
     747         [ #  # ]:          0 :                 field != NH_FLD_IP_DST) {
     748                 :          0 :                 DPAA2_PMD_ERR("Field of IP addr reorder must be IP SRC/DST");
     749                 :          0 :                 return -1;
     750                 :            :         }
     751         [ #  # ]:          0 :         if (ipv4)
     752                 :            :                 prot = NET_PROT_IPV4;
     753                 :            :         else
     754                 :            :                 prot = NET_PROT_IPV6;
     755                 :          0 :         dst_offset = dpaa2_flow_extract_key_offset(key_extract,
     756                 :            :                                 prot, field);
     757         [ #  # ]:          0 :         if (dst_offset < 0) {
     758                 :          0 :                 DPAA2_PMD_ERR("Field %d reorder extract failed", field);
     759                 :          0 :                 return -1;
     760                 :            :         }
     761                 :          0 :         key_src = rule->key_iova + src_offset;
     762                 :          0 :         mask_src = rule->mask_iova + src_offset;
     763                 :          0 :         key_dst = rule->key_iova + dst_offset;
     764                 :          0 :         mask_dst = rule->mask_iova + dst_offset;
     765         [ #  # ]:          0 :         if (ipv4)
     766                 :            :                 len = sizeof(rte_be32_t);
     767                 :            :         else
     768                 :            :                 len = NH_FLD_IPV6_ADDR_SIZE;
     769                 :            : 
     770                 :          0 :         memcpy(tmp, (char *)key_src, len);
     771                 :            :         memset((char *)key_src, 0, len);
     772                 :          0 :         memcpy((char *)key_dst, tmp, len);
     773                 :            : 
     774                 :          0 :         memcpy(tmp, (char *)mask_src, len);
     775                 :            :         memset((char *)mask_src, 0, len);
     776                 :          0 :         memcpy((char *)mask_dst, tmp, len);
     777                 :            : 
     778                 :          0 :         return 0;
     779                 :            : }
     780                 :            : 
     781                 :            : static inline int
     782                 :          0 : dpaa2_flow_rule_move_ipaddr_tail(
     783                 :            :         struct rte_flow *flow, struct dpaa2_dev_priv *priv,
     784                 :            :         int fs_group)
     785                 :            : {
     786                 :            :         int ret;
     787                 :            :         enum net_prot prot;
     788                 :            : 
     789         [ #  # ]:          0 :         if (flow->ipaddr_rule.ipaddr_type == FLOW_NONE_IPADDR)
     790                 :            :                 return 0;
     791                 :            : 
     792         [ #  # ]:          0 :         if (flow->ipaddr_rule.ipaddr_type == FLOW_IPV4_ADDR)
     793                 :            :                 prot = NET_PROT_IPV4;
     794                 :            :         else
     795                 :            :                 prot = NET_PROT_IPV6;
     796                 :            : 
     797         [ #  # ]:          0 :         if (flow->ipaddr_rule.qos_ipsrc_offset >= 0) {
     798                 :          0 :                 ret = _dpaa2_flow_rule_move_ipaddr_tail(
     799                 :            :                                 &priv->extract.qos_key_extract,
     800                 :            :                                 &flow->qos_rule,
     801                 :            :                                 flow->ipaddr_rule.qos_ipsrc_offset,
     802                 :            :                                 NH_FLD_IP_SRC, prot == NET_PROT_IPV4);
     803         [ #  # ]:          0 :                 if (ret) {
     804                 :          0 :                         DPAA2_PMD_ERR("QoS src address reorder failed");
     805                 :          0 :                         return -1;
     806                 :            :                 }
     807                 :          0 :                 flow->ipaddr_rule.qos_ipsrc_offset =
     808                 :          0 :                         dpaa2_flow_extract_key_offset(
     809                 :            :                                 &priv->extract.qos_key_extract,
     810                 :            :                                 prot, NH_FLD_IP_SRC);
     811                 :            :         }
     812                 :            : 
     813         [ #  # ]:          0 :         if (flow->ipaddr_rule.qos_ipdst_offset >= 0) {
     814                 :          0 :                 ret = _dpaa2_flow_rule_move_ipaddr_tail(
     815                 :            :                                 &priv->extract.qos_key_extract,
     816                 :            :                                 &flow->qos_rule,
     817                 :            :                                 flow->ipaddr_rule.qos_ipdst_offset,
     818                 :            :                                 NH_FLD_IP_DST, prot == NET_PROT_IPV4);
     819         [ #  # ]:          0 :                 if (ret) {
     820                 :          0 :                         DPAA2_PMD_ERR("QoS dst address reorder failed");
     821                 :          0 :                         return -1;
     822                 :            :                 }
     823                 :          0 :                 flow->ipaddr_rule.qos_ipdst_offset =
     824                 :          0 :                         dpaa2_flow_extract_key_offset(
     825                 :            :                                 &priv->extract.qos_key_extract,
     826                 :            :                                 prot, NH_FLD_IP_DST);
     827                 :            :         }
     828                 :            : 
     829         [ #  # ]:          0 :         if (flow->ipaddr_rule.fs_ipsrc_offset >= 0) {
     830                 :          0 :                 ret = _dpaa2_flow_rule_move_ipaddr_tail(
     831                 :            :                                 &priv->extract.tc_key_extract[fs_group],
     832                 :            :                                 &flow->fs_rule,
     833                 :            :                                 flow->ipaddr_rule.fs_ipsrc_offset,
     834                 :            :                                 NH_FLD_IP_SRC, prot == NET_PROT_IPV4);
     835         [ #  # ]:          0 :                 if (ret) {
     836                 :          0 :                         DPAA2_PMD_ERR("FS src address reorder failed");
     837                 :          0 :                         return -1;
     838                 :            :                 }
     839                 :          0 :                 flow->ipaddr_rule.fs_ipsrc_offset =
     840                 :          0 :                         dpaa2_flow_extract_key_offset(
     841                 :            :                                 &priv->extract.tc_key_extract[fs_group],
     842                 :            :                                 prot, NH_FLD_IP_SRC);
     843                 :            :         }
     844         [ #  # ]:          0 :         if (flow->ipaddr_rule.fs_ipdst_offset >= 0) {
     845                 :          0 :                 ret = _dpaa2_flow_rule_move_ipaddr_tail(
     846                 :            :                                 &priv->extract.tc_key_extract[fs_group],
     847                 :            :                                 &flow->fs_rule,
     848                 :            :                                 flow->ipaddr_rule.fs_ipdst_offset,
     849                 :            :                                 NH_FLD_IP_DST, prot == NET_PROT_IPV4);
     850         [ #  # ]:          0 :                 if (ret) {
     851                 :          0 :                         DPAA2_PMD_ERR("FS dst address reorder failed");
     852                 :          0 :                         return -1;
     853                 :            :                 }
     854                 :          0 :                 flow->ipaddr_rule.fs_ipdst_offset =
     855                 :          0 :                         dpaa2_flow_extract_key_offset(
     856                 :            :                                 &priv->extract.tc_key_extract[fs_group],
     857                 :            :                                 prot, NH_FLD_IP_DST);
     858                 :            :         }
     859                 :            : 
     860                 :            :         return 0;
     861                 :            : }
     862                 :            : 
     863                 :            : static int
     864                 :          0 : dpaa2_flow_extract_support(
     865                 :            :         const uint8_t *mask_src,
     866                 :            :         enum rte_flow_item_type type)
     867                 :            : {
     868                 :            :         char mask[64];
     869                 :            :         int i, size = 0;
     870                 :            :         const char *mask_support = 0;
     871                 :            : 
     872   [ #  #  #  #  :          0 :         switch (type) {
          #  #  #  #  #  
                      # ]
     873                 :            :         case RTE_FLOW_ITEM_TYPE_ETH:
     874                 :            :                 mask_support = (const char *)&dpaa2_flow_item_eth_mask;
     875                 :            :                 size = sizeof(struct rte_flow_item_eth);
     876                 :            :                 break;
     877                 :          0 :         case RTE_FLOW_ITEM_TYPE_VLAN:
     878                 :            :                 mask_support = (const char *)&dpaa2_flow_item_vlan_mask;
     879                 :            :                 size = sizeof(struct rte_flow_item_vlan);
     880                 :          0 :                 break;
     881                 :          0 :         case RTE_FLOW_ITEM_TYPE_IPV4:
     882                 :            :                 mask_support = (const char *)&dpaa2_flow_item_ipv4_mask;
     883                 :            :                 size = sizeof(struct rte_flow_item_ipv4);
     884                 :          0 :                 break;
     885                 :          0 :         case RTE_FLOW_ITEM_TYPE_IPV6:
     886                 :            :                 mask_support = (const char *)&dpaa2_flow_item_ipv6_mask;
     887                 :            :                 size = sizeof(struct rte_flow_item_ipv6);
     888                 :          0 :                 break;
     889                 :          0 :         case RTE_FLOW_ITEM_TYPE_ICMP:
     890                 :            :                 mask_support = (const char *)&dpaa2_flow_item_icmp_mask;
     891                 :            :                 size = sizeof(struct rte_flow_item_icmp);
     892                 :          0 :                 break;
     893                 :          0 :         case RTE_FLOW_ITEM_TYPE_UDP:
     894                 :            :                 mask_support = (const char *)&dpaa2_flow_item_udp_mask;
     895                 :            :                 size = sizeof(struct rte_flow_item_udp);
     896                 :          0 :                 break;
     897                 :          0 :         case RTE_FLOW_ITEM_TYPE_TCP:
     898                 :            :                 mask_support = (const char *)&dpaa2_flow_item_tcp_mask;
     899                 :            :                 size = sizeof(struct rte_flow_item_tcp);
     900                 :          0 :                 break;
     901                 :          0 :         case RTE_FLOW_ITEM_TYPE_SCTP:
     902                 :            :                 mask_support = (const char *)&dpaa2_flow_item_sctp_mask;
     903                 :            :                 size = sizeof(struct rte_flow_item_sctp);
     904                 :          0 :                 break;
     905                 :          0 :         case RTE_FLOW_ITEM_TYPE_GRE:
     906                 :            :                 mask_support = (const char *)&dpaa2_flow_item_gre_mask;
     907                 :            :                 size = sizeof(struct rte_flow_item_gre);
     908                 :          0 :                 break;
     909                 :            :         default:
     910                 :            :                 return -1;
     911                 :            :         }
     912                 :            : 
     913                 :          0 :         memcpy(mask, mask_support, size);
     914                 :            : 
     915         [ #  # ]:          0 :         for (i = 0; i < size; i++)
     916                 :          0 :                 mask[i] = (mask[i] | mask_src[i]);
     917                 :            : 
     918         [ #  # ]:          0 :         if (memcmp(mask, mask_support, size))
     919                 :          0 :                 return -1;
     920                 :            : 
     921                 :            :         return 0;
     922                 :            : }
     923                 :            : 
     924                 :            : static int
     925                 :          0 : dpaa2_configure_flow_eth(struct rte_flow *flow,
     926                 :            :                          struct rte_eth_dev *dev,
     927                 :            :                          const struct rte_flow_attr *attr,
     928                 :            :                          const struct rte_flow_item *pattern,
     929                 :            :                          const struct rte_flow_action actions[] __rte_unused,
     930                 :            :                          struct rte_flow_error *error __rte_unused,
     931                 :            :                          int *device_configured)
     932                 :            : {
     933                 :            :         int index, ret;
     934                 :            :         int local_cfg = 0;
     935                 :            :         uint32_t group;
     936                 :            :         const struct rte_flow_item_eth *spec, *mask;
     937                 :            : 
     938                 :            :         /* TODO: Currently upper bound of range parameter is not implemented */
     939                 :            :         const struct rte_flow_item_eth *last __rte_unused;
     940                 :          0 :         struct dpaa2_dev_priv *priv = dev->data->dev_private;
     941                 :          0 :         const char zero_cmp[RTE_ETHER_ADDR_LEN] = {0};
     942                 :            : 
     943                 :          0 :         group = attr->group;
     944                 :            : 
     945                 :            :         /* Parse pattern list to get the matching parameters */
     946                 :          0 :         spec    = (const struct rte_flow_item_eth *)pattern->spec;
     947                 :            :         last    = (const struct rte_flow_item_eth *)pattern->last;
     948                 :          0 :         mask    = (const struct rte_flow_item_eth *)
     949         [ #  # ]:          0 :                 (pattern->mask ? pattern->mask : &dpaa2_flow_item_eth_mask);
     950         [ #  # ]:          0 :         if (!spec) {
     951                 :            :                 /* Don't care any field of eth header,
     952                 :            :                  * only care eth protocol.
     953                 :            :                  */
     954                 :          0 :                 DPAA2_PMD_WARN("No pattern spec for Eth flow, just skip");
     955                 :          0 :                 return 0;
     956                 :            :         }
     957                 :            : 
     958                 :            :         /* Get traffic class index and flow id to be configured */
     959                 :          0 :         flow->tc_id = group;
     960                 :          0 :         flow->tc_index = attr->priority;
     961                 :            : 
     962         [ #  # ]:          0 :         if (dpaa2_flow_extract_support((const uint8_t *)mask,
     963                 :            :                 RTE_FLOW_ITEM_TYPE_ETH)) {
     964                 :          0 :                 DPAA2_PMD_WARN("Extract field(s) of ethernet not support.");
     965                 :            : 
     966                 :          0 :                 return -1;
     967                 :            :         }
     968                 :            : 
     969         [ #  # ]:          0 :         if (memcmp((const char *)&mask->hdr.src_addr, zero_cmp, RTE_ETHER_ADDR_LEN)) {
     970                 :            :                 index = dpaa2_flow_extract_search(
     971                 :            :                                 &priv->extract.qos_key_extract.dpkg,
     972                 :            :                                 NET_PROT_ETH, NH_FLD_ETH_SA);
     973         [ #  # ]:          0 :                 if (index < 0) {
     974                 :          0 :                         ret = dpaa2_flow_extract_add(
     975                 :            :                                         &priv->extract.qos_key_extract,
     976                 :            :                                         NET_PROT_ETH, NH_FLD_ETH_SA,
     977                 :            :                                         RTE_ETHER_ADDR_LEN);
     978         [ #  # ]:          0 :                         if (ret) {
     979                 :          0 :                                 DPAA2_PMD_ERR("QoS Extract add ETH_SA failed.");
     980                 :            : 
     981                 :          0 :                                 return -1;
     982                 :            :                         }
     983                 :            :                         local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
     984                 :            :                 }
     985                 :            :                 index = dpaa2_flow_extract_search(
     986                 :            :                                 &priv->extract.tc_key_extract[group].dpkg,
     987                 :            :                                 NET_PROT_ETH, NH_FLD_ETH_SA);
     988         [ #  # ]:          0 :                 if (index < 0) {
     989                 :          0 :                         ret = dpaa2_flow_extract_add(
     990                 :            :                                         &priv->extract.tc_key_extract[group],
     991                 :            :                                         NET_PROT_ETH, NH_FLD_ETH_SA,
     992                 :            :                                         RTE_ETHER_ADDR_LEN);
     993         [ #  # ]:          0 :                         if (ret) {
     994                 :          0 :                                 DPAA2_PMD_ERR("FS Extract add ETH_SA failed.");
     995                 :          0 :                                 return -1;
     996                 :            :                         }
     997                 :          0 :                         local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
     998                 :            :                 }
     999                 :            : 
    1000                 :          0 :                 ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
    1001         [ #  # ]:          0 :                 if (ret) {
    1002                 :          0 :                         DPAA2_PMD_ERR(
    1003                 :            :                                 "Move ipaddr before ETH_SA rule set failed");
    1004                 :          0 :                         return -1;
    1005                 :            :                 }
    1006                 :            : 
    1007                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    1008                 :            :                                 &priv->extract.qos_key_extract,
    1009                 :            :                                 &flow->qos_rule,
    1010                 :            :                                 NET_PROT_ETH,
    1011                 :            :                                 NH_FLD_ETH_SA,
    1012                 :          0 :                                 &spec->hdr.src_addr.addr_bytes,
    1013                 :          0 :                                 &mask->hdr.src_addr.addr_bytes,
    1014                 :            :                                 sizeof(struct rte_ether_addr));
    1015         [ #  # ]:          0 :                 if (ret) {
    1016                 :          0 :                         DPAA2_PMD_ERR("QoS NH_FLD_ETH_SA rule data set failed");
    1017                 :          0 :                         return -1;
    1018                 :            :                 }
    1019                 :            : 
    1020                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    1021                 :            :                                 &priv->extract.tc_key_extract[group],
    1022                 :            :                                 &flow->fs_rule,
    1023                 :            :                                 NET_PROT_ETH,
    1024                 :            :                                 NH_FLD_ETH_SA,
    1025                 :            :                                 &spec->hdr.src_addr.addr_bytes,
    1026                 :            :                                 &mask->hdr.src_addr.addr_bytes,
    1027                 :            :                                 sizeof(struct rte_ether_addr));
    1028         [ #  # ]:          0 :                 if (ret) {
    1029                 :          0 :                         DPAA2_PMD_ERR("FS NH_FLD_ETH_SA rule data set failed");
    1030                 :          0 :                         return -1;
    1031                 :            :                 }
    1032                 :            :         }
    1033                 :            : 
    1034         [ #  # ]:          0 :         if (memcmp((const char *)&mask->hdr.dst_addr, zero_cmp, RTE_ETHER_ADDR_LEN)) {
    1035                 :            :                 index = dpaa2_flow_extract_search(
    1036                 :            :                                 &priv->extract.qos_key_extract.dpkg,
    1037                 :            :                                 NET_PROT_ETH, NH_FLD_ETH_DA);
    1038         [ #  # ]:          0 :                 if (index < 0) {
    1039                 :          0 :                         ret = dpaa2_flow_extract_add(
    1040                 :            :                                         &priv->extract.qos_key_extract,
    1041                 :            :                                         NET_PROT_ETH, NH_FLD_ETH_DA,
    1042                 :            :                                         RTE_ETHER_ADDR_LEN);
    1043         [ #  # ]:          0 :                         if (ret) {
    1044                 :          0 :                                 DPAA2_PMD_ERR("QoS Extract add ETH_DA failed.");
    1045                 :            : 
    1046                 :          0 :                                 return -1;
    1047                 :            :                         }
    1048                 :          0 :                         local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
    1049                 :            :                 }
    1050                 :            : 
    1051                 :            :                 index = dpaa2_flow_extract_search(
    1052                 :            :                                 &priv->extract.tc_key_extract[group].dpkg,
    1053                 :            :                                 NET_PROT_ETH, NH_FLD_ETH_DA);
    1054         [ #  # ]:          0 :                 if (index < 0) {
    1055                 :          0 :                         ret = dpaa2_flow_extract_add(
    1056                 :            :                                         &priv->extract.tc_key_extract[group],
    1057                 :            :                                         NET_PROT_ETH, NH_FLD_ETH_DA,
    1058                 :            :                                         RTE_ETHER_ADDR_LEN);
    1059         [ #  # ]:          0 :                         if (ret) {
    1060                 :          0 :                                 DPAA2_PMD_ERR("FS Extract add ETH_DA failed.");
    1061                 :            : 
    1062                 :          0 :                                 return -1;
    1063                 :            :                         }
    1064                 :          0 :                         local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
    1065                 :            :                 }
    1066                 :            : 
    1067                 :          0 :                 ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
    1068         [ #  # ]:          0 :                 if (ret) {
    1069                 :          0 :                         DPAA2_PMD_ERR(
    1070                 :            :                                 "Move ipaddr before ETH DA rule set failed");
    1071                 :          0 :                         return -1;
    1072                 :            :                 }
    1073                 :            : 
    1074                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    1075                 :            :                                 &priv->extract.qos_key_extract,
    1076                 :            :                                 &flow->qos_rule,
    1077                 :            :                                 NET_PROT_ETH,
    1078                 :            :                                 NH_FLD_ETH_DA,
    1079                 :          0 :                                 &spec->hdr.dst_addr.addr_bytes,
    1080                 :          0 :                                 &mask->hdr.dst_addr.addr_bytes,
    1081                 :            :                                 sizeof(struct rte_ether_addr));
    1082         [ #  # ]:          0 :                 if (ret) {
    1083                 :          0 :                         DPAA2_PMD_ERR("QoS NH_FLD_ETH_DA rule data set failed");
    1084                 :          0 :                         return -1;
    1085                 :            :                 }
    1086                 :            : 
    1087                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    1088                 :            :                                 &priv->extract.tc_key_extract[group],
    1089                 :            :                                 &flow->fs_rule,
    1090                 :            :                                 NET_PROT_ETH,
    1091                 :            :                                 NH_FLD_ETH_DA,
    1092                 :            :                                 &spec->hdr.dst_addr.addr_bytes,
    1093                 :            :                                 &mask->hdr.dst_addr.addr_bytes,
    1094                 :            :                                 sizeof(struct rte_ether_addr));
    1095         [ #  # ]:          0 :                 if (ret) {
    1096                 :          0 :                         DPAA2_PMD_ERR("FS NH_FLD_ETH_DA rule data set failed");
    1097                 :          0 :                         return -1;
    1098                 :            :                 }
    1099                 :            :         }
    1100                 :            : 
    1101         [ #  # ]:          0 :         if (memcmp((const char *)&mask->hdr.ether_type, zero_cmp, sizeof(rte_be16_t))) {
    1102                 :            :                 index = dpaa2_flow_extract_search(
    1103                 :            :                                 &priv->extract.qos_key_extract.dpkg,
    1104                 :            :                                 NET_PROT_ETH, NH_FLD_ETH_TYPE);
    1105         [ #  # ]:          0 :                 if (index < 0) {
    1106                 :          0 :                         ret = dpaa2_flow_extract_add(
    1107                 :            :                                         &priv->extract.qos_key_extract,
    1108                 :            :                                         NET_PROT_ETH, NH_FLD_ETH_TYPE,
    1109                 :            :                                         RTE_ETHER_TYPE_LEN);
    1110         [ #  # ]:          0 :                         if (ret) {
    1111                 :          0 :                                 DPAA2_PMD_ERR("QoS Extract add ETH_TYPE failed.");
    1112                 :            : 
    1113                 :          0 :                                 return -1;
    1114                 :            :                         }
    1115                 :          0 :                         local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
    1116                 :            :                 }
    1117                 :            :                 index = dpaa2_flow_extract_search(
    1118                 :            :                                 &priv->extract.tc_key_extract[group].dpkg,
    1119                 :            :                                 NET_PROT_ETH, NH_FLD_ETH_TYPE);
    1120         [ #  # ]:          0 :                 if (index < 0) {
    1121                 :          0 :                         ret = dpaa2_flow_extract_add(
    1122                 :            :                                         &priv->extract.tc_key_extract[group],
    1123                 :            :                                         NET_PROT_ETH, NH_FLD_ETH_TYPE,
    1124                 :            :                                         RTE_ETHER_TYPE_LEN);
    1125         [ #  # ]:          0 :                         if (ret) {
    1126                 :          0 :                                 DPAA2_PMD_ERR("FS Extract add ETH_TYPE failed.");
    1127                 :            : 
    1128                 :          0 :                                 return -1;
    1129                 :            :                         }
    1130                 :          0 :                         local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
    1131                 :            :                 }
    1132                 :            : 
    1133                 :          0 :                 ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
    1134         [ #  # ]:          0 :                 if (ret) {
    1135                 :          0 :                         DPAA2_PMD_ERR(
    1136                 :            :                                 "Move ipaddr before ETH TYPE rule set failed");
    1137                 :          0 :                                 return -1;
    1138                 :            :                 }
    1139                 :            : 
    1140                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    1141                 :            :                                 &priv->extract.qos_key_extract,
    1142                 :            :                                 &flow->qos_rule,
    1143                 :            :                                 NET_PROT_ETH,
    1144                 :            :                                 NH_FLD_ETH_TYPE,
    1145                 :          0 :                                 &spec->hdr.ether_type,
    1146                 :            :                                 &mask->hdr.ether_type,
    1147                 :            :                                 sizeof(rte_be16_t));
    1148         [ #  # ]:          0 :                 if (ret) {
    1149                 :          0 :                         DPAA2_PMD_ERR("QoS NH_FLD_ETH_TYPE rule data set failed");
    1150                 :          0 :                         return -1;
    1151                 :            :                 }
    1152                 :            : 
    1153                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    1154                 :            :                                 &priv->extract.tc_key_extract[group],
    1155                 :            :                                 &flow->fs_rule,
    1156                 :            :                                 NET_PROT_ETH,
    1157                 :            :                                 NH_FLD_ETH_TYPE,
    1158                 :            :                                 &spec->hdr.ether_type,
    1159                 :            :                                 &mask->hdr.ether_type,
    1160                 :            :                                 sizeof(rte_be16_t));
    1161         [ #  # ]:          0 :                 if (ret) {
    1162                 :          0 :                         DPAA2_PMD_ERR("FS NH_FLD_ETH_TYPE rule data set failed");
    1163                 :          0 :                         return -1;
    1164                 :            :                 }
    1165                 :            :         }
    1166                 :            : 
    1167                 :          0 :         (*device_configured) |= local_cfg;
    1168                 :            : 
    1169                 :          0 :         return 0;
    1170                 :            : }
    1171                 :            : 
    1172                 :            : static int
    1173                 :          0 : dpaa2_configure_flow_vlan(struct rte_flow *flow,
    1174                 :            :                           struct rte_eth_dev *dev,
    1175                 :            :                           const struct rte_flow_attr *attr,
    1176                 :            :                           const struct rte_flow_item *pattern,
    1177                 :            :                           const struct rte_flow_action actions[] __rte_unused,
    1178                 :            :                           struct rte_flow_error *error __rte_unused,
    1179                 :            :                           int *device_configured)
    1180                 :            : {
    1181                 :            :         int index, ret;
    1182                 :            :         int local_cfg = 0;
    1183                 :            :         uint32_t group;
    1184                 :            :         const struct rte_flow_item_vlan *spec, *mask;
    1185                 :            : 
    1186                 :            :         const struct rte_flow_item_vlan *last __rte_unused;
    1187                 :          0 :         struct dpaa2_dev_priv *priv = dev->data->dev_private;
    1188                 :            : 
    1189                 :          0 :         group = attr->group;
    1190                 :            : 
    1191                 :            :         /* Parse pattern list to get the matching parameters */
    1192                 :          0 :         spec    = (const struct rte_flow_item_vlan *)pattern->spec;
    1193                 :            :         last    = (const struct rte_flow_item_vlan *)pattern->last;
    1194                 :          0 :         mask    = (const struct rte_flow_item_vlan *)
    1195         [ #  # ]:          0 :                 (pattern->mask ? pattern->mask : &dpaa2_flow_item_vlan_mask);
    1196                 :            : 
    1197                 :            :         /* Get traffic class index and flow id to be configured */
    1198                 :          0 :         flow->tc_id = group;
    1199                 :          0 :         flow->tc_index = attr->priority;
    1200                 :            : 
    1201         [ #  # ]:          0 :         if (!spec) {
    1202                 :            :                 /* Don't care any field of vlan header,
    1203                 :            :                  * only care vlan protocol.
    1204                 :            :                  */
    1205                 :            :                 /* Eth type is actually used for vLan classification.
    1206                 :            :                  */
    1207                 :            :                 struct proto_discrimination proto;
    1208                 :            : 
    1209                 :            :                 index = dpaa2_flow_extract_search(
    1210                 :            :                                 &priv->extract.qos_key_extract.dpkg,
    1211                 :            :                                 NET_PROT_ETH, NH_FLD_ETH_TYPE);
    1212         [ #  # ]:          0 :                 if (index < 0) {
    1213                 :          0 :                         ret = dpaa2_flow_proto_discrimination_extract(
    1214                 :            :                                                 &priv->extract.qos_key_extract,
    1215                 :            :                                                 RTE_FLOW_ITEM_TYPE_ETH);
    1216         [ #  # ]:          0 :                         if (ret) {
    1217                 :          0 :                                 DPAA2_PMD_ERR(
    1218                 :            :                                 "QoS Ext ETH_TYPE to discriminate vLan failed");
    1219                 :            : 
    1220                 :          0 :                                 return -1;
    1221                 :            :                         }
    1222                 :            :                         local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
    1223                 :            :                 }
    1224                 :            : 
    1225                 :            :                 index = dpaa2_flow_extract_search(
    1226                 :            :                                 &priv->extract.tc_key_extract[group].dpkg,
    1227                 :            :                                 NET_PROT_ETH, NH_FLD_ETH_TYPE);
    1228         [ #  # ]:          0 :                 if (index < 0) {
    1229                 :          0 :                         ret = dpaa2_flow_proto_discrimination_extract(
    1230                 :            :                                         &priv->extract.tc_key_extract[group],
    1231                 :            :                                         RTE_FLOW_ITEM_TYPE_ETH);
    1232         [ #  # ]:          0 :                         if (ret) {
    1233                 :          0 :                                 DPAA2_PMD_ERR(
    1234                 :            :                                 "FS Ext ETH_TYPE to discriminate vLan failed.");
    1235                 :            : 
    1236                 :          0 :                                 return -1;
    1237                 :            :                         }
    1238                 :          0 :                         local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
    1239                 :            :                 }
    1240                 :            : 
    1241                 :          0 :                 ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
    1242         [ #  # ]:          0 :                 if (ret) {
    1243                 :          0 :                         DPAA2_PMD_ERR(
    1244                 :            :                         "Move ipaddr before vLan discrimination set failed");
    1245                 :          0 :                         return -1;
    1246                 :            :                 }
    1247                 :            : 
    1248                 :          0 :                 proto.type = RTE_FLOW_ITEM_TYPE_ETH;
    1249                 :          0 :                 proto.eth_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
    1250                 :          0 :                 ret = dpaa2_flow_proto_discrimination_rule(priv, flow,
    1251                 :            :                                                         proto, group);
    1252         [ #  # ]:          0 :                 if (ret) {
    1253                 :          0 :                         DPAA2_PMD_ERR("vLan discrimination rule set failed");
    1254                 :          0 :                         return -1;
    1255                 :            :                 }
    1256                 :            : 
    1257                 :          0 :                 (*device_configured) |= local_cfg;
    1258                 :            : 
    1259                 :          0 :                 return 0;
    1260                 :            :         }
    1261                 :            : 
    1262         [ #  # ]:          0 :         if (dpaa2_flow_extract_support((const uint8_t *)mask,
    1263                 :            :                 RTE_FLOW_ITEM_TYPE_VLAN)) {
    1264                 :          0 :                 DPAA2_PMD_WARN("Extract field(s) of vlan not support.");
    1265                 :            : 
    1266                 :          0 :                 return -1;
    1267                 :            :         }
    1268                 :            : 
    1269         [ #  # ]:          0 :         if (!mask->hdr.vlan_tci)
    1270                 :            :                 return 0;
    1271                 :            : 
    1272                 :            :         index = dpaa2_flow_extract_search(
    1273                 :            :                                 &priv->extract.qos_key_extract.dpkg,
    1274                 :            :                                 NET_PROT_VLAN, NH_FLD_VLAN_TCI);
    1275         [ #  # ]:          0 :         if (index < 0) {
    1276                 :          0 :                 ret = dpaa2_flow_extract_add(
    1277                 :            :                                                 &priv->extract.qos_key_extract,
    1278                 :            :                                                 NET_PROT_VLAN,
    1279                 :            :                                                 NH_FLD_VLAN_TCI,
    1280                 :            :                                                 sizeof(rte_be16_t));
    1281         [ #  # ]:          0 :                 if (ret) {
    1282                 :          0 :                         DPAA2_PMD_ERR("QoS Extract add VLAN_TCI failed.");
    1283                 :            : 
    1284                 :          0 :                         return -1;
    1285                 :            :                 }
    1286                 :            :                 local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
    1287                 :            :         }
    1288                 :            : 
    1289                 :            :         index = dpaa2_flow_extract_search(
    1290                 :            :                         &priv->extract.tc_key_extract[group].dpkg,
    1291                 :            :                         NET_PROT_VLAN, NH_FLD_VLAN_TCI);
    1292         [ #  # ]:          0 :         if (index < 0) {
    1293                 :          0 :                 ret = dpaa2_flow_extract_add(
    1294                 :            :                                 &priv->extract.tc_key_extract[group],
    1295                 :            :                                 NET_PROT_VLAN,
    1296                 :            :                                 NH_FLD_VLAN_TCI,
    1297                 :            :                                 sizeof(rte_be16_t));
    1298         [ #  # ]:          0 :                 if (ret) {
    1299                 :          0 :                         DPAA2_PMD_ERR("FS Extract add VLAN_TCI failed.");
    1300                 :            : 
    1301                 :          0 :                         return -1;
    1302                 :            :                 }
    1303                 :          0 :                 local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
    1304                 :            :         }
    1305                 :            : 
    1306                 :          0 :         ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
    1307         [ #  # ]:          0 :         if (ret) {
    1308                 :          0 :                 DPAA2_PMD_ERR(
    1309                 :            :                         "Move ipaddr before VLAN TCI rule set failed");
    1310                 :          0 :                 return -1;
    1311                 :            :         }
    1312                 :            : 
    1313                 :          0 :         ret = dpaa2_flow_rule_data_set(&priv->extract.qos_key_extract,
    1314                 :            :                                 &flow->qos_rule,
    1315                 :            :                                 NET_PROT_VLAN,
    1316                 :            :                                 NH_FLD_VLAN_TCI,
    1317                 :          0 :                                 &spec->hdr.vlan_tci,
    1318                 :          0 :                                 &mask->hdr.vlan_tci,
    1319                 :            :                                 sizeof(rte_be16_t));
    1320         [ #  # ]:          0 :         if (ret) {
    1321                 :          0 :                 DPAA2_PMD_ERR("QoS NH_FLD_VLAN_TCI rule data set failed");
    1322                 :          0 :                 return -1;
    1323                 :            :         }
    1324                 :            : 
    1325                 :          0 :         ret = dpaa2_flow_rule_data_set(
    1326                 :            :                         &priv->extract.tc_key_extract[group],
    1327                 :            :                         &flow->fs_rule,
    1328                 :            :                         NET_PROT_VLAN,
    1329                 :            :                         NH_FLD_VLAN_TCI,
    1330                 :            :                         &spec->hdr.vlan_tci,
    1331                 :            :                         &mask->hdr.vlan_tci,
    1332                 :            :                         sizeof(rte_be16_t));
    1333         [ #  # ]:          0 :         if (ret) {
    1334                 :          0 :                 DPAA2_PMD_ERR("FS NH_FLD_VLAN_TCI rule data set failed");
    1335                 :          0 :                 return -1;
    1336                 :            :         }
    1337                 :            : 
    1338                 :          0 :         (*device_configured) |= local_cfg;
    1339                 :            : 
    1340                 :          0 :         return 0;
    1341                 :            : }
    1342                 :            : 
    1343                 :            : static int
    1344                 :          0 : dpaa2_configure_flow_ip_discrimation(
    1345                 :            :         struct dpaa2_dev_priv *priv, struct rte_flow *flow,
    1346                 :            :         const struct rte_flow_item *pattern,
    1347                 :            :         int *local_cfg, int *device_configured,
    1348                 :            :         uint32_t group)
    1349                 :            : {
    1350                 :            :         int index, ret;
    1351                 :            :         struct proto_discrimination proto;
    1352                 :            : 
    1353                 :            :         index = dpaa2_flow_extract_search(
    1354                 :            :                         &priv->extract.qos_key_extract.dpkg,
    1355                 :            :                         NET_PROT_ETH, NH_FLD_ETH_TYPE);
    1356         [ #  # ]:          0 :         if (index < 0) {
    1357                 :          0 :                 ret = dpaa2_flow_proto_discrimination_extract(
    1358                 :            :                                 &priv->extract.qos_key_extract,
    1359                 :            :                                 RTE_FLOW_ITEM_TYPE_ETH);
    1360         [ #  # ]:          0 :                 if (ret) {
    1361                 :          0 :                         DPAA2_PMD_ERR(
    1362                 :            :                         "QoS Extract ETH_TYPE to discriminate IP failed.");
    1363                 :          0 :                         return -1;
    1364                 :            :                 }
    1365                 :          0 :                 (*local_cfg) |= DPAA2_QOS_TABLE_RECONFIGURE;
    1366                 :            :         }
    1367                 :            : 
    1368                 :            :         index = dpaa2_flow_extract_search(
    1369                 :            :                         &priv->extract.tc_key_extract[group].dpkg,
    1370                 :            :                         NET_PROT_ETH, NH_FLD_ETH_TYPE);
    1371         [ #  # ]:          0 :         if (index < 0) {
    1372                 :          0 :                 ret = dpaa2_flow_proto_discrimination_extract(
    1373                 :            :                                 &priv->extract.tc_key_extract[group],
    1374                 :            :                                 RTE_FLOW_ITEM_TYPE_ETH);
    1375         [ #  # ]:          0 :                 if (ret) {
    1376                 :          0 :                         DPAA2_PMD_ERR(
    1377                 :            :                         "FS Extract ETH_TYPE to discriminate IP failed.");
    1378                 :          0 :                         return -1;
    1379                 :            :                 }
    1380                 :          0 :                 (*local_cfg) |= DPAA2_FS_TABLE_RECONFIGURE;
    1381                 :            :         }
    1382                 :            : 
    1383                 :          0 :         ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
    1384         [ #  # ]:          0 :         if (ret) {
    1385                 :          0 :                 DPAA2_PMD_ERR(
    1386                 :            :                         "Move ipaddr before IP discrimination set failed");
    1387                 :          0 :                 return -1;
    1388                 :            :         }
    1389                 :            : 
    1390                 :          0 :         proto.type = RTE_FLOW_ITEM_TYPE_ETH;
    1391         [ #  # ]:          0 :         if (pattern->type == RTE_FLOW_ITEM_TYPE_IPV4)
    1392                 :          0 :                 proto.eth_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
    1393                 :            :         else
    1394                 :          0 :                 proto.eth_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6);
    1395                 :          0 :         ret = dpaa2_flow_proto_discrimination_rule(priv, flow, proto, group);
    1396         [ #  # ]:          0 :         if (ret) {
    1397                 :          0 :                 DPAA2_PMD_ERR("IP discrimination rule set failed");
    1398                 :          0 :                 return -1;
    1399                 :            :         }
    1400                 :            : 
    1401                 :          0 :         (*device_configured) |= (*local_cfg);
    1402                 :            : 
    1403                 :          0 :         return 0;
    1404                 :            : }
    1405                 :            : 
    1406                 :            : 
    1407                 :            : static int
    1408                 :          0 : dpaa2_configure_flow_generic_ip(
    1409                 :            :         struct rte_flow *flow,
    1410                 :            :         struct rte_eth_dev *dev,
    1411                 :            :         const struct rte_flow_attr *attr,
    1412                 :            :         const struct rte_flow_item *pattern,
    1413                 :            :         const struct rte_flow_action actions[] __rte_unused,
    1414                 :            :         struct rte_flow_error *error __rte_unused,
    1415                 :            :         int *device_configured)
    1416                 :            : {
    1417                 :            :         int index, ret;
    1418                 :          0 :         int local_cfg = 0;
    1419                 :            :         uint32_t group;
    1420                 :            :         const struct rte_flow_item_ipv4 *spec_ipv4 = 0,
    1421                 :            :                 *mask_ipv4 = 0;
    1422                 :            :         const struct rte_flow_item_ipv6 *spec_ipv6 = 0,
    1423                 :            :                 *mask_ipv6 = 0;
    1424                 :            :         const void *key, *mask;
    1425                 :            :         enum net_prot prot;
    1426                 :            : 
    1427                 :          0 :         struct dpaa2_dev_priv *priv = dev->data->dev_private;
    1428                 :          0 :         const char zero_cmp[NH_FLD_IPV6_ADDR_SIZE] = {0};
    1429                 :            :         int size;
    1430                 :            : 
    1431                 :          0 :         group = attr->group;
    1432                 :            : 
    1433                 :            :         /* Parse pattern list to get the matching parameters */
    1434         [ #  # ]:          0 :         if (pattern->type == RTE_FLOW_ITEM_TYPE_IPV4) {
    1435                 :          0 :                 spec_ipv4 = (const struct rte_flow_item_ipv4 *)pattern->spec;
    1436                 :          0 :                 mask_ipv4 = (const struct rte_flow_item_ipv4 *)
    1437         [ #  # ]:          0 :                         (pattern->mask ? pattern->mask :
    1438                 :            :                                         &dpaa2_flow_item_ipv4_mask);
    1439                 :            :         } else {
    1440                 :          0 :                 spec_ipv6 = (const struct rte_flow_item_ipv6 *)pattern->spec;
    1441                 :          0 :                 mask_ipv6 = (const struct rte_flow_item_ipv6 *)
    1442         [ #  # ]:          0 :                         (pattern->mask ? pattern->mask :
    1443                 :            :                                         &dpaa2_flow_item_ipv6_mask);
    1444                 :            :         }
    1445                 :            : 
    1446                 :            :         /* Get traffic class index and flow id to be configured */
    1447                 :          0 :         flow->tc_id = group;
    1448                 :          0 :         flow->tc_index = attr->priority;
    1449                 :            : 
    1450                 :          0 :         ret = dpaa2_configure_flow_ip_discrimation(priv,
    1451                 :            :                         flow, pattern, &local_cfg,
    1452                 :            :                         device_configured, group);
    1453         [ #  # ]:          0 :         if (ret) {
    1454                 :          0 :                 DPAA2_PMD_ERR("IP discrimination failed!");
    1455                 :          0 :                 return -1;
    1456                 :            :         }
    1457                 :            : 
    1458         [ #  # ]:          0 :         if (!spec_ipv4 && !spec_ipv6)
    1459                 :            :                 return 0;
    1460                 :            : 
    1461         [ #  # ]:          0 :         if (mask_ipv4) {
    1462         [ #  # ]:          0 :                 if (dpaa2_flow_extract_support((const uint8_t *)mask_ipv4,
    1463                 :            :                         RTE_FLOW_ITEM_TYPE_IPV4)) {
    1464                 :          0 :                         DPAA2_PMD_WARN("Extract field(s) of IPv4 not support.");
    1465                 :            : 
    1466                 :          0 :                         return -1;
    1467                 :            :                 }
    1468                 :            :         }
    1469                 :            : 
    1470         [ #  # ]:          0 :         if (mask_ipv6) {
    1471         [ #  # ]:          0 :                 if (dpaa2_flow_extract_support((const uint8_t *)mask_ipv6,
    1472                 :            :                         RTE_FLOW_ITEM_TYPE_IPV6)) {
    1473                 :          0 :                         DPAA2_PMD_WARN("Extract field(s) of IPv6 not support.");
    1474                 :            : 
    1475                 :          0 :                         return -1;
    1476                 :            :                 }
    1477                 :            :         }
    1478                 :            : 
    1479   [ #  #  #  # ]:          0 :         if (mask_ipv4 && (mask_ipv4->hdr.src_addr ||
    1480         [ #  # ]:          0 :                 mask_ipv4->hdr.dst_addr)) {
    1481                 :          0 :                 flow->ipaddr_rule.ipaddr_type = FLOW_IPV4_ADDR;
    1482         [ #  # ]:          0 :         } else if (mask_ipv6 &&
    1483         [ #  # ]:          0 :                 (memcmp((const char *)mask_ipv6->hdr.src_addr,
    1484                 :          0 :                                 zero_cmp, NH_FLD_IPV6_ADDR_SIZE) ||
    1485         [ #  # ]:          0 :                 memcmp((const char *)mask_ipv6->hdr.dst_addr,
    1486                 :            :                                 zero_cmp, NH_FLD_IPV6_ADDR_SIZE))) {
    1487                 :          0 :                 flow->ipaddr_rule.ipaddr_type = FLOW_IPV6_ADDR;
    1488                 :            :         }
    1489                 :            : 
    1490   [ #  #  #  #  :          0 :         if ((mask_ipv4 && mask_ipv4->hdr.src_addr) ||
                   #  # ]
    1491                 :          0 :                 (mask_ipv6 &&
    1492         [ #  # ]:          0 :                         memcmp((const char *)mask_ipv6->hdr.src_addr,
    1493                 :            :                                 zero_cmp, NH_FLD_IPV6_ADDR_SIZE))) {
    1494                 :            :                 index = dpaa2_flow_extract_search(
    1495                 :            :                                 &priv->extract.qos_key_extract.dpkg,
    1496                 :            :                                 NET_PROT_IP, NH_FLD_IP_SRC);
    1497         [ #  # ]:          0 :                 if (index < 0) {
    1498                 :          0 :                         ret = dpaa2_flow_extract_add(
    1499                 :            :                                         &priv->extract.qos_key_extract,
    1500                 :            :                                         NET_PROT_IP,
    1501                 :            :                                         NH_FLD_IP_SRC,
    1502                 :            :                                         0);
    1503         [ #  # ]:          0 :                         if (ret) {
    1504                 :          0 :                                 DPAA2_PMD_ERR("QoS Extract add IP_SRC failed.");
    1505                 :            : 
    1506                 :          0 :                                 return -1;
    1507                 :            :                         }
    1508                 :          0 :                         local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
    1509                 :            :                 }
    1510                 :            : 
    1511                 :            :                 index = dpaa2_flow_extract_search(
    1512                 :            :                                 &priv->extract.tc_key_extract[group].dpkg,
    1513                 :            :                                 NET_PROT_IP, NH_FLD_IP_SRC);
    1514         [ #  # ]:          0 :                 if (index < 0) {
    1515                 :          0 :                         ret = dpaa2_flow_extract_add(
    1516                 :            :                                         &priv->extract.tc_key_extract[group],
    1517                 :            :                                         NET_PROT_IP,
    1518                 :            :                                         NH_FLD_IP_SRC,
    1519                 :            :                                         0);
    1520         [ #  # ]:          0 :                         if (ret) {
    1521                 :          0 :                                 DPAA2_PMD_ERR("FS Extract add IP_SRC failed.");
    1522                 :            : 
    1523                 :          0 :                                 return -1;
    1524                 :            :                         }
    1525                 :          0 :                         local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
    1526                 :            :                 }
    1527                 :            : 
    1528         [ #  # ]:          0 :                 if (spec_ipv4)
    1529                 :          0 :                         key = &spec_ipv4->hdr.src_addr;
    1530                 :            :                 else
    1531                 :          0 :                         key = &spec_ipv6->hdr.src_addr[0];
    1532         [ #  # ]:          0 :                 if (mask_ipv4) {
    1533                 :          0 :                         mask = &mask_ipv4->hdr.src_addr;
    1534                 :            :                         size = NH_FLD_IPV4_ADDR_SIZE;
    1535                 :            :                         prot = NET_PROT_IPV4;
    1536                 :            :                 } else {
    1537                 :          0 :                         mask = &mask_ipv6->hdr.src_addr[0];
    1538                 :            :                         size = NH_FLD_IPV6_ADDR_SIZE;
    1539                 :            :                         prot = NET_PROT_IPV6;
    1540                 :            :                 }
    1541                 :            : 
    1542                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    1543                 :            :                                 &priv->extract.qos_key_extract,
    1544                 :            :                                 &flow->qos_rule,
    1545                 :            :                                 prot, NH_FLD_IP_SRC,
    1546                 :            :                                 key,    mask, size);
    1547         [ #  # ]:          0 :                 if (ret) {
    1548                 :          0 :                         DPAA2_PMD_ERR("QoS NH_FLD_IP_SRC rule data set failed");
    1549                 :          0 :                         return -1;
    1550                 :            :                 }
    1551                 :            : 
    1552                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    1553                 :            :                                 &priv->extract.tc_key_extract[group],
    1554                 :            :                                 &flow->fs_rule,
    1555                 :            :                                 prot, NH_FLD_IP_SRC,
    1556                 :            :                                 key,    mask, size);
    1557         [ #  # ]:          0 :                 if (ret) {
    1558                 :          0 :                         DPAA2_PMD_ERR("FS NH_FLD_IP_SRC rule data set failed");
    1559                 :          0 :                         return -1;
    1560                 :            :                 }
    1561                 :            : 
    1562                 :          0 :                 flow->ipaddr_rule.qos_ipsrc_offset =
    1563                 :          0 :                         dpaa2_flow_extract_key_offset(
    1564                 :            :                                 &priv->extract.qos_key_extract,
    1565                 :            :                                 prot, NH_FLD_IP_SRC);
    1566                 :          0 :                 flow->ipaddr_rule.fs_ipsrc_offset =
    1567                 :          0 :                         dpaa2_flow_extract_key_offset(
    1568                 :            :                                 &priv->extract.tc_key_extract[group],
    1569                 :            :                                 prot, NH_FLD_IP_SRC);
    1570                 :            :         }
    1571                 :            : 
    1572   [ #  #  #  #  :          0 :         if ((mask_ipv4 && mask_ipv4->hdr.dst_addr) ||
                   #  # ]
    1573                 :          0 :                 (mask_ipv6 &&
    1574         [ #  # ]:          0 :                         memcmp((const char *)mask_ipv6->hdr.dst_addr,
    1575                 :            :                                 zero_cmp, NH_FLD_IPV6_ADDR_SIZE))) {
    1576                 :            :                 index = dpaa2_flow_extract_search(
    1577                 :            :                                 &priv->extract.qos_key_extract.dpkg,
    1578                 :            :                                 NET_PROT_IP, NH_FLD_IP_DST);
    1579         [ #  # ]:          0 :                 if (index < 0) {
    1580         [ #  # ]:          0 :                         if (mask_ipv4)
    1581                 :            :                                 size = NH_FLD_IPV4_ADDR_SIZE;
    1582                 :            :                         else
    1583                 :            :                                 size = NH_FLD_IPV6_ADDR_SIZE;
    1584                 :          0 :                         ret = dpaa2_flow_extract_add(
    1585                 :            :                                         &priv->extract.qos_key_extract,
    1586                 :            :                                         NET_PROT_IP,
    1587                 :            :                                         NH_FLD_IP_DST,
    1588                 :            :                                         size);
    1589         [ #  # ]:          0 :                         if (ret) {
    1590                 :          0 :                                 DPAA2_PMD_ERR("QoS Extract add IP_DST failed.");
    1591                 :            : 
    1592                 :          0 :                                 return -1;
    1593                 :            :                         }
    1594                 :          0 :                         local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
    1595                 :            :                 }
    1596                 :            : 
    1597                 :            :                 index = dpaa2_flow_extract_search(
    1598                 :            :                                 &priv->extract.tc_key_extract[group].dpkg,
    1599                 :            :                                 NET_PROT_IP, NH_FLD_IP_DST);
    1600         [ #  # ]:          0 :                 if (index < 0) {
    1601         [ #  # ]:          0 :                         if (mask_ipv4)
    1602                 :            :                                 size = NH_FLD_IPV4_ADDR_SIZE;
    1603                 :            :                         else
    1604                 :            :                                 size = NH_FLD_IPV6_ADDR_SIZE;
    1605                 :          0 :                         ret = dpaa2_flow_extract_add(
    1606                 :            :                                         &priv->extract.tc_key_extract[group],
    1607                 :            :                                         NET_PROT_IP,
    1608                 :            :                                         NH_FLD_IP_DST,
    1609                 :            :                                         size);
    1610         [ #  # ]:          0 :                         if (ret) {
    1611                 :          0 :                                 DPAA2_PMD_ERR("FS Extract add IP_DST failed.");
    1612                 :            : 
    1613                 :          0 :                                 return -1;
    1614                 :            :                         }
    1615                 :          0 :                         local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
    1616                 :            :                 }
    1617                 :            : 
    1618         [ #  # ]:          0 :                 if (spec_ipv4)
    1619                 :          0 :                         key = &spec_ipv4->hdr.dst_addr;
    1620                 :            :                 else
    1621                 :          0 :                         key = spec_ipv6->hdr.dst_addr;
    1622         [ #  # ]:          0 :                 if (mask_ipv4) {
    1623                 :          0 :                         mask = &mask_ipv4->hdr.dst_addr;
    1624                 :            :                         size = NH_FLD_IPV4_ADDR_SIZE;
    1625                 :            :                         prot = NET_PROT_IPV4;
    1626                 :            :                 } else {
    1627                 :          0 :                         mask = &mask_ipv6->hdr.dst_addr[0];
    1628                 :            :                         size = NH_FLD_IPV6_ADDR_SIZE;
    1629                 :            :                         prot = NET_PROT_IPV6;
    1630                 :            :                 }
    1631                 :            : 
    1632                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    1633                 :            :                                 &priv->extract.qos_key_extract,
    1634                 :            :                                 &flow->qos_rule,
    1635                 :            :                                 prot, NH_FLD_IP_DST,
    1636                 :            :                                 key,    mask, size);
    1637         [ #  # ]:          0 :                 if (ret) {
    1638                 :          0 :                         DPAA2_PMD_ERR("QoS NH_FLD_IP_DST rule data set failed");
    1639                 :          0 :                         return -1;
    1640                 :            :                 }
    1641                 :            : 
    1642                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    1643                 :            :                                 &priv->extract.tc_key_extract[group],
    1644                 :            :                                 &flow->fs_rule,
    1645                 :            :                                 prot, NH_FLD_IP_DST,
    1646                 :            :                                 key,    mask, size);
    1647         [ #  # ]:          0 :                 if (ret) {
    1648                 :          0 :                         DPAA2_PMD_ERR("FS NH_FLD_IP_DST rule data set failed");
    1649                 :          0 :                         return -1;
    1650                 :            :                 }
    1651                 :          0 :                 flow->ipaddr_rule.qos_ipdst_offset =
    1652                 :          0 :                         dpaa2_flow_extract_key_offset(
    1653                 :            :                                 &priv->extract.qos_key_extract,
    1654                 :            :                                 prot, NH_FLD_IP_DST);
    1655                 :          0 :                 flow->ipaddr_rule.fs_ipdst_offset =
    1656                 :          0 :                         dpaa2_flow_extract_key_offset(
    1657                 :            :                                 &priv->extract.tc_key_extract[group],
    1658                 :            :                                 prot, NH_FLD_IP_DST);
    1659                 :            :         }
    1660                 :            : 
    1661   [ #  #  #  #  :          0 :         if ((mask_ipv4 && mask_ipv4->hdr.next_proto_id) ||
                   #  # ]
    1662         [ #  # ]:          0 :                 (mask_ipv6 && mask_ipv6->hdr.proto)) {
    1663                 :            :                 index = dpaa2_flow_extract_search(
    1664                 :            :                                 &priv->extract.qos_key_extract.dpkg,
    1665                 :            :                                 NET_PROT_IP, NH_FLD_IP_PROTO);
    1666         [ #  # ]:          0 :                 if (index < 0) {
    1667                 :          0 :                         ret = dpaa2_flow_extract_add(
    1668                 :            :                                 &priv->extract.qos_key_extract,
    1669                 :            :                                 NET_PROT_IP,
    1670                 :            :                                 NH_FLD_IP_PROTO,
    1671                 :            :                                 NH_FLD_IP_PROTO_SIZE);
    1672         [ #  # ]:          0 :                         if (ret) {
    1673                 :          0 :                                 DPAA2_PMD_ERR("QoS Extract add IP_DST failed.");
    1674                 :            : 
    1675                 :          0 :                                 return -1;
    1676                 :            :                         }
    1677                 :          0 :                         local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
    1678                 :            :                 }
    1679                 :            : 
    1680                 :            :                 index = dpaa2_flow_extract_search(
    1681                 :            :                                 &priv->extract.tc_key_extract[group].dpkg,
    1682                 :            :                                 NET_PROT_IP, NH_FLD_IP_PROTO);
    1683         [ #  # ]:          0 :                 if (index < 0) {
    1684                 :          0 :                         ret = dpaa2_flow_extract_add(
    1685                 :            :                                         &priv->extract.tc_key_extract[group],
    1686                 :            :                                         NET_PROT_IP,
    1687                 :            :                                         NH_FLD_IP_PROTO,
    1688                 :            :                                         NH_FLD_IP_PROTO_SIZE);
    1689         [ #  # ]:          0 :                         if (ret) {
    1690                 :          0 :                                 DPAA2_PMD_ERR("FS Extract add IP_DST failed.");
    1691                 :            : 
    1692                 :          0 :                                 return -1;
    1693                 :            :                         }
    1694                 :          0 :                         local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
    1695                 :            :                 }
    1696                 :            : 
    1697                 :          0 :                 ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
    1698         [ #  # ]:          0 :                 if (ret) {
    1699                 :          0 :                         DPAA2_PMD_ERR(
    1700                 :            :                                 "Move ipaddr after NH_FLD_IP_PROTO rule set failed");
    1701                 :          0 :                         return -1;
    1702                 :            :                 }
    1703                 :            : 
    1704         [ #  # ]:          0 :                 if (spec_ipv4)
    1705                 :          0 :                         key = &spec_ipv4->hdr.next_proto_id;
    1706                 :            :                 else
    1707                 :          0 :                         key = &spec_ipv6->hdr.proto;
    1708         [ #  # ]:          0 :                 if (mask_ipv4)
    1709                 :          0 :                         mask = &mask_ipv4->hdr.next_proto_id;
    1710                 :            :                 else
    1711                 :          0 :                         mask = &mask_ipv6->hdr.proto;
    1712                 :            : 
    1713                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    1714                 :            :                                 &priv->extract.qos_key_extract,
    1715                 :            :                                 &flow->qos_rule,
    1716                 :            :                                 NET_PROT_IP,
    1717                 :            :                                 NH_FLD_IP_PROTO,
    1718                 :            :                                 key,    mask, NH_FLD_IP_PROTO_SIZE);
    1719         [ #  # ]:          0 :                 if (ret) {
    1720                 :          0 :                         DPAA2_PMD_ERR("QoS NH_FLD_IP_PROTO rule data set failed");
    1721                 :          0 :                         return -1;
    1722                 :            :                 }
    1723                 :            : 
    1724                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    1725                 :            :                                 &priv->extract.tc_key_extract[group],
    1726                 :            :                                 &flow->fs_rule,
    1727                 :            :                                 NET_PROT_IP,
    1728                 :            :                                 NH_FLD_IP_PROTO,
    1729                 :            :                                 key,    mask, NH_FLD_IP_PROTO_SIZE);
    1730         [ #  # ]:          0 :                 if (ret) {
    1731                 :          0 :                         DPAA2_PMD_ERR("FS NH_FLD_IP_PROTO rule data set failed");
    1732                 :          0 :                         return -1;
    1733                 :            :                 }
    1734                 :            :         }
    1735                 :            : 
    1736                 :          0 :         (*device_configured) |= local_cfg;
    1737                 :            : 
    1738                 :          0 :         return 0;
    1739                 :            : }
    1740                 :            : 
    1741                 :            : static int
    1742                 :          0 : dpaa2_configure_flow_icmp(struct rte_flow *flow,
    1743                 :            :                           struct rte_eth_dev *dev,
    1744                 :            :                           const struct rte_flow_attr *attr,
    1745                 :            :                           const struct rte_flow_item *pattern,
    1746                 :            :                           const struct rte_flow_action actions[] __rte_unused,
    1747                 :            :                           struct rte_flow_error *error __rte_unused,
    1748                 :            :                           int *device_configured)
    1749                 :            : {
    1750                 :            :         int index, ret;
    1751                 :            :         int local_cfg = 0;
    1752                 :            :         uint32_t group;
    1753                 :            :         const struct rte_flow_item_icmp *spec, *mask;
    1754                 :            : 
    1755                 :            :         const struct rte_flow_item_icmp *last __rte_unused;
    1756                 :          0 :         struct dpaa2_dev_priv *priv = dev->data->dev_private;
    1757                 :            : 
    1758                 :          0 :         group = attr->group;
    1759                 :            : 
    1760                 :            :         /* Parse pattern list to get the matching parameters */
    1761                 :          0 :         spec    = (const struct rte_flow_item_icmp *)pattern->spec;
    1762                 :            :         last    = (const struct rte_flow_item_icmp *)pattern->last;
    1763                 :          0 :         mask    = (const struct rte_flow_item_icmp *)
    1764         [ #  # ]:          0 :                 (pattern->mask ? pattern->mask : &dpaa2_flow_item_icmp_mask);
    1765                 :            : 
    1766                 :            :         /* Get traffic class index and flow id to be configured */
    1767                 :          0 :         flow->tc_id = group;
    1768                 :          0 :         flow->tc_index = attr->priority;
    1769                 :            : 
    1770         [ #  # ]:          0 :         if (!spec) {
    1771                 :            :                 /* Don't care any field of ICMP header,
    1772                 :            :                  * only care ICMP protocol.
    1773                 :            :                  * Example: flow create 0 ingress pattern icmp /
    1774                 :            :                  */
    1775                 :            :                 /* Next proto of Generical IP is actually used
    1776                 :            :                  * for ICMP identification.
    1777                 :            :                  */
    1778                 :            :                 struct proto_discrimination proto;
    1779                 :            : 
    1780                 :            :                 index = dpaa2_flow_extract_search(
    1781                 :            :                                 &priv->extract.qos_key_extract.dpkg,
    1782                 :            :                                 NET_PROT_IP, NH_FLD_IP_PROTO);
    1783         [ #  # ]:          0 :                 if (index < 0) {
    1784                 :          0 :                         ret = dpaa2_flow_proto_discrimination_extract(
    1785                 :            :                                         &priv->extract.qos_key_extract,
    1786                 :            :                                         DPAA2_FLOW_ITEM_TYPE_GENERIC_IP);
    1787         [ #  # ]:          0 :                         if (ret) {
    1788                 :          0 :                                 DPAA2_PMD_ERR(
    1789                 :            :                                         "QoS Extract IP protocol to discriminate ICMP failed.");
    1790                 :            : 
    1791                 :          0 :                                 return -1;
    1792                 :            :                         }
    1793                 :            :                         local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
    1794                 :            :                 }
    1795                 :            : 
    1796                 :            :                 index = dpaa2_flow_extract_search(
    1797                 :            :                                 &priv->extract.tc_key_extract[group].dpkg,
    1798                 :            :                                 NET_PROT_IP, NH_FLD_IP_PROTO);
    1799         [ #  # ]:          0 :                 if (index < 0) {
    1800                 :          0 :                         ret = dpaa2_flow_proto_discrimination_extract(
    1801                 :            :                                         &priv->extract.tc_key_extract[group],
    1802                 :            :                                         DPAA2_FLOW_ITEM_TYPE_GENERIC_IP);
    1803         [ #  # ]:          0 :                         if (ret) {
    1804                 :          0 :                                 DPAA2_PMD_ERR(
    1805                 :            :                                         "FS Extract IP protocol to discriminate ICMP failed.");
    1806                 :            : 
    1807                 :          0 :                                 return -1;
    1808                 :            :                         }
    1809                 :          0 :                         local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
    1810                 :            :                 }
    1811                 :            : 
    1812                 :          0 :                 ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
    1813         [ #  # ]:          0 :                 if (ret) {
    1814                 :          0 :                         DPAA2_PMD_ERR(
    1815                 :            :                                 "Move IP addr before ICMP discrimination set failed");
    1816                 :          0 :                         return -1;
    1817                 :            :                 }
    1818                 :            : 
    1819                 :          0 :                 proto.type = DPAA2_FLOW_ITEM_TYPE_GENERIC_IP;
    1820                 :          0 :                 proto.ip_proto = IPPROTO_ICMP;
    1821                 :          0 :                 ret = dpaa2_flow_proto_discrimination_rule(priv, flow,
    1822                 :            :                                                         proto, group);
    1823         [ #  # ]:          0 :                 if (ret) {
    1824                 :          0 :                         DPAA2_PMD_ERR("ICMP discrimination rule set failed");
    1825                 :          0 :                         return -1;
    1826                 :            :                 }
    1827                 :            : 
    1828                 :          0 :                 (*device_configured) |= local_cfg;
    1829                 :            : 
    1830                 :          0 :                 return 0;
    1831                 :            :         }
    1832                 :            : 
    1833         [ #  # ]:          0 :         if (dpaa2_flow_extract_support((const uint8_t *)mask,
    1834                 :            :                 RTE_FLOW_ITEM_TYPE_ICMP)) {
    1835                 :          0 :                 DPAA2_PMD_WARN("Extract field(s) of ICMP not support.");
    1836                 :            : 
    1837                 :          0 :                 return -1;
    1838                 :            :         }
    1839                 :            : 
    1840         [ #  # ]:          0 :         if (mask->hdr.icmp_type) {
    1841                 :            :                 index = dpaa2_flow_extract_search(
    1842                 :            :                                 &priv->extract.qos_key_extract.dpkg,
    1843                 :            :                                 NET_PROT_ICMP, NH_FLD_ICMP_TYPE);
    1844         [ #  # ]:          0 :                 if (index < 0) {
    1845                 :          0 :                         ret = dpaa2_flow_extract_add(
    1846                 :            :                                         &priv->extract.qos_key_extract,
    1847                 :            :                                         NET_PROT_ICMP,
    1848                 :            :                                         NH_FLD_ICMP_TYPE,
    1849                 :            :                                         NH_FLD_ICMP_TYPE_SIZE);
    1850         [ #  # ]:          0 :                         if (ret) {
    1851                 :          0 :                                 DPAA2_PMD_ERR("QoS Extract add ICMP_TYPE failed.");
    1852                 :            : 
    1853                 :          0 :                                 return -1;
    1854                 :            :                         }
    1855                 :            :                         local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
    1856                 :            :                 }
    1857                 :            : 
    1858                 :            :                 index = dpaa2_flow_extract_search(
    1859                 :            :                                 &priv->extract.tc_key_extract[group].dpkg,
    1860                 :            :                                 NET_PROT_ICMP, NH_FLD_ICMP_TYPE);
    1861         [ #  # ]:          0 :                 if (index < 0) {
    1862                 :          0 :                         ret = dpaa2_flow_extract_add(
    1863                 :            :                                         &priv->extract.tc_key_extract[group],
    1864                 :            :                                         NET_PROT_ICMP,
    1865                 :            :                                         NH_FLD_ICMP_TYPE,
    1866                 :            :                                         NH_FLD_ICMP_TYPE_SIZE);
    1867         [ #  # ]:          0 :                         if (ret) {
    1868                 :          0 :                                 DPAA2_PMD_ERR("FS Extract add ICMP_TYPE failed.");
    1869                 :            : 
    1870                 :          0 :                                 return -1;
    1871                 :            :                         }
    1872                 :          0 :                         local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
    1873                 :            :                 }
    1874                 :            : 
    1875                 :          0 :                 ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
    1876         [ #  # ]:          0 :                 if (ret) {
    1877                 :          0 :                         DPAA2_PMD_ERR(
    1878                 :            :                                 "Move ipaddr before ICMP TYPE set failed");
    1879                 :          0 :                         return -1;
    1880                 :            :                 }
    1881                 :            : 
    1882                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    1883                 :            :                                 &priv->extract.qos_key_extract,
    1884                 :            :                                 &flow->qos_rule,
    1885                 :            :                                 NET_PROT_ICMP,
    1886                 :            :                                 NH_FLD_ICMP_TYPE,
    1887                 :          0 :                                 &spec->hdr.icmp_type,
    1888                 :          0 :                                 &mask->hdr.icmp_type,
    1889                 :            :                                 NH_FLD_ICMP_TYPE_SIZE);
    1890         [ #  # ]:          0 :                 if (ret) {
    1891                 :          0 :                         DPAA2_PMD_ERR("QoS NH_FLD_ICMP_TYPE rule data set failed");
    1892                 :          0 :                         return -1;
    1893                 :            :                 }
    1894                 :            : 
    1895                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    1896                 :            :                                 &priv->extract.tc_key_extract[group],
    1897                 :            :                                 &flow->fs_rule,
    1898                 :            :                                 NET_PROT_ICMP,
    1899                 :            :                                 NH_FLD_ICMP_TYPE,
    1900                 :            :                                 &spec->hdr.icmp_type,
    1901                 :            :                                 &mask->hdr.icmp_type,
    1902                 :            :                                 NH_FLD_ICMP_TYPE_SIZE);
    1903         [ #  # ]:          0 :                 if (ret) {
    1904                 :          0 :                         DPAA2_PMD_ERR("FS NH_FLD_ICMP_TYPE rule data set failed");
    1905                 :          0 :                         return -1;
    1906                 :            :                 }
    1907                 :            :         }
    1908                 :            : 
    1909         [ #  # ]:          0 :         if (mask->hdr.icmp_code) {
    1910                 :            :                 index = dpaa2_flow_extract_search(
    1911                 :            :                                 &priv->extract.qos_key_extract.dpkg,
    1912                 :            :                                 NET_PROT_ICMP, NH_FLD_ICMP_CODE);
    1913         [ #  # ]:          0 :                 if (index < 0) {
    1914                 :          0 :                         ret = dpaa2_flow_extract_add(
    1915                 :            :                                         &priv->extract.qos_key_extract,
    1916                 :            :                                         NET_PROT_ICMP,
    1917                 :            :                                         NH_FLD_ICMP_CODE,
    1918                 :            :                                         NH_FLD_ICMP_CODE_SIZE);
    1919         [ #  # ]:          0 :                         if (ret) {
    1920                 :          0 :                                 DPAA2_PMD_ERR("QoS Extract add ICMP_CODE failed.");
    1921                 :            : 
    1922                 :          0 :                                 return -1;
    1923                 :            :                         }
    1924                 :          0 :                         local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
    1925                 :            :                 }
    1926                 :            : 
    1927                 :            :                 index = dpaa2_flow_extract_search(
    1928                 :            :                                 &priv->extract.tc_key_extract[group].dpkg,
    1929                 :            :                                 NET_PROT_ICMP, NH_FLD_ICMP_CODE);
    1930         [ #  # ]:          0 :                 if (index < 0) {
    1931                 :          0 :                         ret = dpaa2_flow_extract_add(
    1932                 :            :                                         &priv->extract.tc_key_extract[group],
    1933                 :            :                                         NET_PROT_ICMP,
    1934                 :            :                                         NH_FLD_ICMP_CODE,
    1935                 :            :                                         NH_FLD_ICMP_CODE_SIZE);
    1936         [ #  # ]:          0 :                         if (ret) {
    1937                 :          0 :                                 DPAA2_PMD_ERR("FS Extract add ICMP_CODE failed.");
    1938                 :            : 
    1939                 :          0 :                                 return -1;
    1940                 :            :                         }
    1941                 :          0 :                         local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
    1942                 :            :                 }
    1943                 :            : 
    1944                 :          0 :                 ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
    1945         [ #  # ]:          0 :                 if (ret) {
    1946                 :          0 :                         DPAA2_PMD_ERR(
    1947                 :            :                                 "Move ipaddr after ICMP CODE set failed");
    1948                 :          0 :                         return -1;
    1949                 :            :                 }
    1950                 :            : 
    1951                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    1952                 :            :                                 &priv->extract.qos_key_extract,
    1953                 :            :                                 &flow->qos_rule,
    1954                 :            :                                 NET_PROT_ICMP,
    1955                 :            :                                 NH_FLD_ICMP_CODE,
    1956                 :          0 :                                 &spec->hdr.icmp_code,
    1957                 :          0 :                                 &mask->hdr.icmp_code,
    1958                 :            :                                 NH_FLD_ICMP_CODE_SIZE);
    1959         [ #  # ]:          0 :                 if (ret) {
    1960                 :          0 :                         DPAA2_PMD_ERR("QoS NH_FLD_ICMP_CODE rule data set failed");
    1961                 :          0 :                         return -1;
    1962                 :            :                 }
    1963                 :            : 
    1964                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    1965                 :            :                                 &priv->extract.tc_key_extract[group],
    1966                 :            :                                 &flow->fs_rule,
    1967                 :            :                                 NET_PROT_ICMP,
    1968                 :            :                                 NH_FLD_ICMP_CODE,
    1969                 :            :                                 &spec->hdr.icmp_code,
    1970                 :            :                                 &mask->hdr.icmp_code,
    1971                 :            :                                 NH_FLD_ICMP_CODE_SIZE);
    1972         [ #  # ]:          0 :                 if (ret) {
    1973                 :          0 :                         DPAA2_PMD_ERR("FS NH_FLD_ICMP_CODE rule data set failed");
    1974                 :          0 :                         return -1;
    1975                 :            :                 }
    1976                 :            :         }
    1977                 :            : 
    1978                 :          0 :         (*device_configured) |= local_cfg;
    1979                 :            : 
    1980                 :          0 :         return 0;
    1981                 :            : }
    1982                 :            : 
    1983                 :            : static int
    1984                 :          0 : dpaa2_configure_flow_udp(struct rte_flow *flow,
    1985                 :            :                          struct rte_eth_dev *dev,
    1986                 :            :                           const struct rte_flow_attr *attr,
    1987                 :            :                           const struct rte_flow_item *pattern,
    1988                 :            :                           const struct rte_flow_action actions[] __rte_unused,
    1989                 :            :                           struct rte_flow_error *error __rte_unused,
    1990                 :            :                           int *device_configured)
    1991                 :            : {
    1992                 :            :         int index, ret;
    1993                 :            :         int local_cfg = 0;
    1994                 :            :         uint32_t group;
    1995                 :            :         const struct rte_flow_item_udp *spec, *mask;
    1996                 :            : 
    1997                 :            :         const struct rte_flow_item_udp *last __rte_unused;
    1998                 :          0 :         struct dpaa2_dev_priv *priv = dev->data->dev_private;
    1999                 :            : 
    2000                 :          0 :         group = attr->group;
    2001                 :            : 
    2002                 :            :         /* Parse pattern list to get the matching parameters */
    2003                 :          0 :         spec    = (const struct rte_flow_item_udp *)pattern->spec;
    2004                 :            :         last    = (const struct rte_flow_item_udp *)pattern->last;
    2005                 :          0 :         mask    = (const struct rte_flow_item_udp *)
    2006         [ #  # ]:          0 :                 (pattern->mask ? pattern->mask : &dpaa2_flow_item_udp_mask);
    2007                 :            : 
    2008                 :            :         /* Get traffic class index and flow id to be configured */
    2009                 :          0 :         flow->tc_id = group;
    2010                 :          0 :         flow->tc_index = attr->priority;
    2011                 :            : 
    2012   [ #  #  #  # ]:          0 :         if (!spec || !mc_l4_port_identification) {
    2013                 :            :                 struct proto_discrimination proto;
    2014                 :            : 
    2015                 :            :                 index = dpaa2_flow_extract_search(
    2016                 :            :                                 &priv->extract.qos_key_extract.dpkg,
    2017                 :            :                                 NET_PROT_IP, NH_FLD_IP_PROTO);
    2018         [ #  # ]:          0 :                 if (index < 0) {
    2019                 :          0 :                         ret = dpaa2_flow_proto_discrimination_extract(
    2020                 :            :                                         &priv->extract.qos_key_extract,
    2021                 :            :                                         DPAA2_FLOW_ITEM_TYPE_GENERIC_IP);
    2022         [ #  # ]:          0 :                         if (ret) {
    2023                 :          0 :                                 DPAA2_PMD_ERR(
    2024                 :            :                                         "QoS Extract IP protocol to discriminate UDP failed.");
    2025                 :            : 
    2026                 :          0 :                                 return -1;
    2027                 :            :                         }
    2028                 :            :                         local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
    2029                 :            :                 }
    2030                 :            : 
    2031                 :            :                 index = dpaa2_flow_extract_search(
    2032                 :            :                                 &priv->extract.tc_key_extract[group].dpkg,
    2033                 :            :                                 NET_PROT_IP, NH_FLD_IP_PROTO);
    2034         [ #  # ]:          0 :                 if (index < 0) {
    2035                 :          0 :                         ret = dpaa2_flow_proto_discrimination_extract(
    2036                 :            :                                 &priv->extract.tc_key_extract[group],
    2037                 :            :                                 DPAA2_FLOW_ITEM_TYPE_GENERIC_IP);
    2038         [ #  # ]:          0 :                         if (ret) {
    2039                 :          0 :                                 DPAA2_PMD_ERR(
    2040                 :            :                                         "FS Extract IP protocol to discriminate UDP failed.");
    2041                 :            : 
    2042                 :          0 :                                 return -1;
    2043                 :            :                         }
    2044                 :          0 :                         local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
    2045                 :            :                 }
    2046                 :            : 
    2047                 :          0 :                 ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
    2048         [ #  # ]:          0 :                 if (ret) {
    2049                 :          0 :                         DPAA2_PMD_ERR(
    2050                 :            :                                 "Move IP addr before UDP discrimination set failed");
    2051                 :          0 :                         return -1;
    2052                 :            :                 }
    2053                 :            : 
    2054                 :          0 :                 proto.type = DPAA2_FLOW_ITEM_TYPE_GENERIC_IP;
    2055                 :          0 :                 proto.ip_proto = IPPROTO_UDP;
    2056                 :          0 :                 ret = dpaa2_flow_proto_discrimination_rule(priv, flow,
    2057                 :            :                                                         proto, group);
    2058         [ #  # ]:          0 :                 if (ret) {
    2059                 :          0 :                         DPAA2_PMD_ERR("UDP discrimination rule set failed");
    2060                 :          0 :                         return -1;
    2061                 :            :                 }
    2062                 :            : 
    2063                 :          0 :                 (*device_configured) |= local_cfg;
    2064                 :            : 
    2065         [ #  # ]:          0 :                 if (!spec)
    2066                 :            :                         return 0;
    2067                 :            :         }
    2068                 :            : 
    2069         [ #  # ]:          0 :         if (dpaa2_flow_extract_support((const uint8_t *)mask,
    2070                 :            :                 RTE_FLOW_ITEM_TYPE_UDP)) {
    2071                 :          0 :                 DPAA2_PMD_WARN("Extract field(s) of UDP not support.");
    2072                 :            : 
    2073                 :          0 :                 return -1;
    2074                 :            :         }
    2075                 :            : 
    2076         [ #  # ]:          0 :         if (mask->hdr.src_port) {
    2077                 :            :                 index = dpaa2_flow_extract_search(
    2078                 :            :                                 &priv->extract.qos_key_extract.dpkg,
    2079                 :            :                                 NET_PROT_UDP, NH_FLD_UDP_PORT_SRC);
    2080         [ #  # ]:          0 :                 if (index < 0) {
    2081                 :          0 :                         ret = dpaa2_flow_extract_add(
    2082                 :            :                                         &priv->extract.qos_key_extract,
    2083                 :            :                                 NET_PROT_UDP,
    2084                 :            :                                 NH_FLD_UDP_PORT_SRC,
    2085                 :            :                                 NH_FLD_UDP_PORT_SIZE);
    2086         [ #  # ]:          0 :                         if (ret) {
    2087                 :          0 :                                 DPAA2_PMD_ERR("QoS Extract add UDP_SRC failed.");
    2088                 :            : 
    2089                 :          0 :                                 return -1;
    2090                 :            :                         }
    2091                 :          0 :                         local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
    2092                 :            :                 }
    2093                 :            : 
    2094                 :            :                 index = dpaa2_flow_extract_search(
    2095                 :            :                                 &priv->extract.tc_key_extract[group].dpkg,
    2096                 :            :                                 NET_PROT_UDP, NH_FLD_UDP_PORT_SRC);
    2097         [ #  # ]:          0 :                 if (index < 0) {
    2098                 :          0 :                         ret = dpaa2_flow_extract_add(
    2099                 :            :                                         &priv->extract.tc_key_extract[group],
    2100                 :            :                                         NET_PROT_UDP,
    2101                 :            :                                         NH_FLD_UDP_PORT_SRC,
    2102                 :            :                                         NH_FLD_UDP_PORT_SIZE);
    2103         [ #  # ]:          0 :                         if (ret) {
    2104                 :          0 :                                 DPAA2_PMD_ERR("FS Extract add UDP_SRC failed.");
    2105                 :            : 
    2106                 :          0 :                                 return -1;
    2107                 :            :                         }
    2108                 :          0 :                         local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
    2109                 :            :                 }
    2110                 :            : 
    2111                 :          0 :                 ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
    2112         [ #  # ]:          0 :                 if (ret) {
    2113                 :          0 :                         DPAA2_PMD_ERR(
    2114                 :            :                                 "Move ipaddr before UDP_PORT_SRC set failed");
    2115                 :          0 :                         return -1;
    2116                 :            :                 }
    2117                 :            : 
    2118                 :          0 :                 ret = dpaa2_flow_rule_data_set(&priv->extract.qos_key_extract,
    2119                 :            :                                 &flow->qos_rule,
    2120                 :            :                                 NET_PROT_UDP,
    2121                 :            :                                 NH_FLD_UDP_PORT_SRC,
    2122                 :          0 :                                 &spec->hdr.src_port,
    2123                 :          0 :                                 &mask->hdr.src_port,
    2124                 :            :                                 NH_FLD_UDP_PORT_SIZE);
    2125         [ #  # ]:          0 :                 if (ret) {
    2126                 :          0 :                         DPAA2_PMD_ERR(
    2127                 :            :                                 "QoS NH_FLD_UDP_PORT_SRC rule data set failed");
    2128                 :          0 :                         return -1;
    2129                 :            :                 }
    2130                 :            : 
    2131                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    2132                 :            :                                 &priv->extract.tc_key_extract[group],
    2133                 :            :                                 &flow->fs_rule,
    2134                 :            :                                 NET_PROT_UDP,
    2135                 :            :                                 NH_FLD_UDP_PORT_SRC,
    2136                 :            :                                 &spec->hdr.src_port,
    2137                 :            :                                 &mask->hdr.src_port,
    2138                 :            :                                 NH_FLD_UDP_PORT_SIZE);
    2139         [ #  # ]:          0 :                 if (ret) {
    2140                 :          0 :                         DPAA2_PMD_ERR(
    2141                 :            :                                 "FS NH_FLD_UDP_PORT_SRC rule data set failed");
    2142                 :          0 :                         return -1;
    2143                 :            :                 }
    2144                 :            :         }
    2145                 :            : 
    2146         [ #  # ]:          0 :         if (mask->hdr.dst_port) {
    2147                 :            :                 index = dpaa2_flow_extract_search(
    2148                 :            :                                 &priv->extract.qos_key_extract.dpkg,
    2149                 :            :                                 NET_PROT_UDP, NH_FLD_UDP_PORT_DST);
    2150         [ #  # ]:          0 :                 if (index < 0) {
    2151                 :          0 :                         ret = dpaa2_flow_extract_add(
    2152                 :            :                                         &priv->extract.qos_key_extract,
    2153                 :            :                                         NET_PROT_UDP,
    2154                 :            :                                         NH_FLD_UDP_PORT_DST,
    2155                 :            :                                         NH_FLD_UDP_PORT_SIZE);
    2156         [ #  # ]:          0 :                         if (ret) {
    2157                 :          0 :                                 DPAA2_PMD_ERR("QoS Extract add UDP_DST failed.");
    2158                 :            : 
    2159                 :          0 :                                 return -1;
    2160                 :            :                         }
    2161                 :          0 :                         local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
    2162                 :            :                 }
    2163                 :            : 
    2164                 :            :                 index = dpaa2_flow_extract_search(
    2165                 :            :                                 &priv->extract.tc_key_extract[group].dpkg,
    2166                 :            :                                 NET_PROT_UDP, NH_FLD_UDP_PORT_DST);
    2167         [ #  # ]:          0 :                 if (index < 0) {
    2168                 :          0 :                         ret = dpaa2_flow_extract_add(
    2169                 :            :                                         &priv->extract.tc_key_extract[group],
    2170                 :            :                                         NET_PROT_UDP,
    2171                 :            :                                         NH_FLD_UDP_PORT_DST,
    2172                 :            :                                         NH_FLD_UDP_PORT_SIZE);
    2173         [ #  # ]:          0 :                         if (ret) {
    2174                 :          0 :                                 DPAA2_PMD_ERR("FS Extract add UDP_DST failed.");
    2175                 :            : 
    2176                 :          0 :                                 return -1;
    2177                 :            :                         }
    2178                 :          0 :                         local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
    2179                 :            :                 }
    2180                 :            : 
    2181                 :          0 :                 ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
    2182         [ #  # ]:          0 :                 if (ret) {
    2183                 :          0 :                         DPAA2_PMD_ERR(
    2184                 :            :                                 "Move ipaddr before UDP_PORT_DST set failed");
    2185                 :          0 :                         return -1;
    2186                 :            :                 }
    2187                 :            : 
    2188                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    2189                 :            :                                 &priv->extract.qos_key_extract,
    2190                 :            :                                 &flow->qos_rule,
    2191                 :            :                                 NET_PROT_UDP,
    2192                 :            :                                 NH_FLD_UDP_PORT_DST,
    2193                 :          0 :                                 &spec->hdr.dst_port,
    2194                 :          0 :                                 &mask->hdr.dst_port,
    2195                 :            :                                 NH_FLD_UDP_PORT_SIZE);
    2196         [ #  # ]:          0 :                 if (ret) {
    2197                 :          0 :                         DPAA2_PMD_ERR(
    2198                 :            :                                 "QoS NH_FLD_UDP_PORT_DST rule data set failed");
    2199                 :          0 :                         return -1;
    2200                 :            :                 }
    2201                 :            : 
    2202                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    2203                 :            :                                 &priv->extract.tc_key_extract[group],
    2204                 :            :                                 &flow->fs_rule,
    2205                 :            :                                 NET_PROT_UDP,
    2206                 :            :                                 NH_FLD_UDP_PORT_DST,
    2207                 :            :                                 &spec->hdr.dst_port,
    2208                 :            :                                 &mask->hdr.dst_port,
    2209                 :            :                                 NH_FLD_UDP_PORT_SIZE);
    2210         [ #  # ]:          0 :                 if (ret) {
    2211                 :          0 :                         DPAA2_PMD_ERR(
    2212                 :            :                                 "FS NH_FLD_UDP_PORT_DST rule data set failed");
    2213                 :          0 :                         return -1;
    2214                 :            :                 }
    2215                 :            :         }
    2216                 :            : 
    2217                 :          0 :         (*device_configured) |= local_cfg;
    2218                 :            : 
    2219                 :          0 :         return 0;
    2220                 :            : }
    2221                 :            : 
    2222                 :            : static int
    2223                 :          0 : dpaa2_configure_flow_tcp(struct rte_flow *flow,
    2224                 :            :                          struct rte_eth_dev *dev,
    2225                 :            :                          const struct rte_flow_attr *attr,
    2226                 :            :                          const struct rte_flow_item *pattern,
    2227                 :            :                          const struct rte_flow_action actions[] __rte_unused,
    2228                 :            :                          struct rte_flow_error *error __rte_unused,
    2229                 :            :                          int *device_configured)
    2230                 :            : {
    2231                 :            :         int index, ret;
    2232                 :            :         int local_cfg = 0;
    2233                 :            :         uint32_t group;
    2234                 :            :         const struct rte_flow_item_tcp *spec, *mask;
    2235                 :            : 
    2236                 :            :         const struct rte_flow_item_tcp *last __rte_unused;
    2237                 :          0 :         struct dpaa2_dev_priv *priv = dev->data->dev_private;
    2238                 :            : 
    2239                 :          0 :         group = attr->group;
    2240                 :            : 
    2241                 :            :         /* Parse pattern list to get the matching parameters */
    2242                 :          0 :         spec    = (const struct rte_flow_item_tcp *)pattern->spec;
    2243                 :            :         last    = (const struct rte_flow_item_tcp *)pattern->last;
    2244                 :          0 :         mask    = (const struct rte_flow_item_tcp *)
    2245         [ #  # ]:          0 :                 (pattern->mask ? pattern->mask : &dpaa2_flow_item_tcp_mask);
    2246                 :            : 
    2247                 :            :         /* Get traffic class index and flow id to be configured */
    2248                 :          0 :         flow->tc_id = group;
    2249                 :          0 :         flow->tc_index = attr->priority;
    2250                 :            : 
    2251   [ #  #  #  # ]:          0 :         if (!spec || !mc_l4_port_identification) {
    2252                 :            :                 struct proto_discrimination proto;
    2253                 :            : 
    2254                 :            :                 index = dpaa2_flow_extract_search(
    2255                 :            :                                 &priv->extract.qos_key_extract.dpkg,
    2256                 :            :                                 NET_PROT_IP, NH_FLD_IP_PROTO);
    2257         [ #  # ]:          0 :                 if (index < 0) {
    2258                 :          0 :                         ret = dpaa2_flow_proto_discrimination_extract(
    2259                 :            :                                         &priv->extract.qos_key_extract,
    2260                 :            :                                         DPAA2_FLOW_ITEM_TYPE_GENERIC_IP);
    2261         [ #  # ]:          0 :                         if (ret) {
    2262                 :          0 :                                 DPAA2_PMD_ERR(
    2263                 :            :                                         "QoS Extract IP protocol to discriminate TCP failed.");
    2264                 :            : 
    2265                 :          0 :                                 return -1;
    2266                 :            :                         }
    2267                 :            :                         local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
    2268                 :            :                 }
    2269                 :            : 
    2270                 :            :                 index = dpaa2_flow_extract_search(
    2271                 :            :                                 &priv->extract.tc_key_extract[group].dpkg,
    2272                 :            :                                 NET_PROT_IP, NH_FLD_IP_PROTO);
    2273         [ #  # ]:          0 :                 if (index < 0) {
    2274                 :          0 :                         ret = dpaa2_flow_proto_discrimination_extract(
    2275                 :            :                                 &priv->extract.tc_key_extract[group],
    2276                 :            :                                 DPAA2_FLOW_ITEM_TYPE_GENERIC_IP);
    2277         [ #  # ]:          0 :                         if (ret) {
    2278                 :          0 :                                 DPAA2_PMD_ERR(
    2279                 :            :                                         "FS Extract IP protocol to discriminate TCP failed.");
    2280                 :            : 
    2281                 :          0 :                                 return -1;
    2282                 :            :                         }
    2283                 :          0 :                         local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
    2284                 :            :                 }
    2285                 :            : 
    2286                 :          0 :                 ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
    2287         [ #  # ]:          0 :                 if (ret) {
    2288                 :          0 :                         DPAA2_PMD_ERR(
    2289                 :            :                                 "Move IP addr before TCP discrimination set failed");
    2290                 :          0 :                         return -1;
    2291                 :            :                 }
    2292                 :            : 
    2293                 :          0 :                 proto.type = DPAA2_FLOW_ITEM_TYPE_GENERIC_IP;
    2294                 :          0 :                 proto.ip_proto = IPPROTO_TCP;
    2295                 :          0 :                 ret = dpaa2_flow_proto_discrimination_rule(priv, flow,
    2296                 :            :                                                         proto, group);
    2297         [ #  # ]:          0 :                 if (ret) {
    2298                 :          0 :                         DPAA2_PMD_ERR("TCP discrimination rule set failed");
    2299                 :          0 :                         return -1;
    2300                 :            :                 }
    2301                 :            : 
    2302                 :          0 :                 (*device_configured) |= local_cfg;
    2303                 :            : 
    2304         [ #  # ]:          0 :                 if (!spec)
    2305                 :            :                         return 0;
    2306                 :            :         }
    2307                 :            : 
    2308         [ #  # ]:          0 :         if (dpaa2_flow_extract_support((const uint8_t *)mask,
    2309                 :            :                 RTE_FLOW_ITEM_TYPE_TCP)) {
    2310                 :          0 :                 DPAA2_PMD_WARN("Extract field(s) of TCP not support.");
    2311                 :            : 
    2312                 :          0 :                 return -1;
    2313                 :            :         }
    2314                 :            : 
    2315         [ #  # ]:          0 :         if (mask->hdr.src_port) {
    2316                 :            :                 index = dpaa2_flow_extract_search(
    2317                 :            :                                 &priv->extract.qos_key_extract.dpkg,
    2318                 :            :                                 NET_PROT_TCP, NH_FLD_TCP_PORT_SRC);
    2319         [ #  # ]:          0 :                 if (index < 0) {
    2320                 :          0 :                         ret = dpaa2_flow_extract_add(
    2321                 :            :                                         &priv->extract.qos_key_extract,
    2322                 :            :                                         NET_PROT_TCP,
    2323                 :            :                                         NH_FLD_TCP_PORT_SRC,
    2324                 :            :                                         NH_FLD_TCP_PORT_SIZE);
    2325         [ #  # ]:          0 :                         if (ret) {
    2326                 :          0 :                                 DPAA2_PMD_ERR("QoS Extract add TCP_SRC failed.");
    2327                 :            : 
    2328                 :          0 :                                 return -1;
    2329                 :            :                         }
    2330                 :          0 :                         local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
    2331                 :            :                 }
    2332                 :            : 
    2333                 :            :                 index = dpaa2_flow_extract_search(
    2334                 :            :                                 &priv->extract.tc_key_extract[group].dpkg,
    2335                 :            :                                 NET_PROT_TCP, NH_FLD_TCP_PORT_SRC);
    2336         [ #  # ]:          0 :                 if (index < 0) {
    2337                 :          0 :                         ret = dpaa2_flow_extract_add(
    2338                 :            :                                         &priv->extract.tc_key_extract[group],
    2339                 :            :                                         NET_PROT_TCP,
    2340                 :            :                                         NH_FLD_TCP_PORT_SRC,
    2341                 :            :                                         NH_FLD_TCP_PORT_SIZE);
    2342         [ #  # ]:          0 :                         if (ret) {
    2343                 :          0 :                                 DPAA2_PMD_ERR("FS Extract add TCP_SRC failed.");
    2344                 :            : 
    2345                 :          0 :                                 return -1;
    2346                 :            :                         }
    2347                 :          0 :                         local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
    2348                 :            :                 }
    2349                 :            : 
    2350                 :          0 :                 ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
    2351         [ #  # ]:          0 :                 if (ret) {
    2352                 :          0 :                         DPAA2_PMD_ERR(
    2353                 :            :                                 "Move ipaddr before TCP_PORT_SRC set failed");
    2354                 :          0 :                         return -1;
    2355                 :            :                 }
    2356                 :            : 
    2357                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    2358                 :            :                                 &priv->extract.qos_key_extract,
    2359                 :            :                                 &flow->qos_rule,
    2360                 :            :                                 NET_PROT_TCP,
    2361                 :            :                                 NH_FLD_TCP_PORT_SRC,
    2362                 :          0 :                                 &spec->hdr.src_port,
    2363                 :          0 :                                 &mask->hdr.src_port,
    2364                 :            :                                 NH_FLD_TCP_PORT_SIZE);
    2365         [ #  # ]:          0 :                 if (ret) {
    2366                 :          0 :                         DPAA2_PMD_ERR(
    2367                 :            :                                 "QoS NH_FLD_TCP_PORT_SRC rule data set failed");
    2368                 :          0 :                         return -1;
    2369                 :            :                 }
    2370                 :            : 
    2371                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    2372                 :            :                                 &priv->extract.tc_key_extract[group],
    2373                 :            :                                 &flow->fs_rule,
    2374                 :            :                                 NET_PROT_TCP,
    2375                 :            :                                 NH_FLD_TCP_PORT_SRC,
    2376                 :            :                                 &spec->hdr.src_port,
    2377                 :            :                                 &mask->hdr.src_port,
    2378                 :            :                                 NH_FLD_TCP_PORT_SIZE);
    2379         [ #  # ]:          0 :                 if (ret) {
    2380                 :          0 :                         DPAA2_PMD_ERR(
    2381                 :            :                                 "FS NH_FLD_TCP_PORT_SRC rule data set failed");
    2382                 :          0 :                         return -1;
    2383                 :            :                 }
    2384                 :            :         }
    2385                 :            : 
    2386         [ #  # ]:          0 :         if (mask->hdr.dst_port) {
    2387                 :            :                 index = dpaa2_flow_extract_search(
    2388                 :            :                                 &priv->extract.qos_key_extract.dpkg,
    2389                 :            :                                 NET_PROT_TCP, NH_FLD_TCP_PORT_DST);
    2390         [ #  # ]:          0 :                 if (index < 0) {
    2391                 :          0 :                         ret = dpaa2_flow_extract_add(
    2392                 :            :                                         &priv->extract.qos_key_extract,
    2393                 :            :                                         NET_PROT_TCP,
    2394                 :            :                                         NH_FLD_TCP_PORT_DST,
    2395                 :            :                                         NH_FLD_TCP_PORT_SIZE);
    2396         [ #  # ]:          0 :                         if (ret) {
    2397                 :          0 :                                 DPAA2_PMD_ERR("QoS Extract add TCP_DST failed.");
    2398                 :            : 
    2399                 :          0 :                                 return -1;
    2400                 :            :                         }
    2401                 :          0 :                         local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
    2402                 :            :                 }
    2403                 :            : 
    2404                 :            :                 index = dpaa2_flow_extract_search(
    2405                 :            :                                 &priv->extract.tc_key_extract[group].dpkg,
    2406                 :            :                                 NET_PROT_TCP, NH_FLD_TCP_PORT_DST);
    2407         [ #  # ]:          0 :                 if (index < 0) {
    2408                 :          0 :                         ret = dpaa2_flow_extract_add(
    2409                 :            :                                         &priv->extract.tc_key_extract[group],
    2410                 :            :                                         NET_PROT_TCP,
    2411                 :            :                                         NH_FLD_TCP_PORT_DST,
    2412                 :            :                                         NH_FLD_TCP_PORT_SIZE);
    2413         [ #  # ]:          0 :                         if (ret) {
    2414                 :          0 :                                 DPAA2_PMD_ERR("FS Extract add TCP_DST failed.");
    2415                 :            : 
    2416                 :          0 :                                 return -1;
    2417                 :            :                         }
    2418                 :          0 :                         local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
    2419                 :            :                 }
    2420                 :            : 
    2421                 :          0 :                 ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
    2422         [ #  # ]:          0 :                 if (ret) {
    2423                 :          0 :                         DPAA2_PMD_ERR(
    2424                 :            :                                 "Move ipaddr before TCP_PORT_DST set failed");
    2425                 :          0 :                         return -1;
    2426                 :            :                 }
    2427                 :            : 
    2428                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    2429                 :            :                                 &priv->extract.qos_key_extract,
    2430                 :            :                                 &flow->qos_rule,
    2431                 :            :                                 NET_PROT_TCP,
    2432                 :            :                                 NH_FLD_TCP_PORT_DST,
    2433                 :          0 :                                 &spec->hdr.dst_port,
    2434                 :          0 :                                 &mask->hdr.dst_port,
    2435                 :            :                                 NH_FLD_TCP_PORT_SIZE);
    2436         [ #  # ]:          0 :                 if (ret) {
    2437                 :          0 :                         DPAA2_PMD_ERR(
    2438                 :            :                                 "QoS NH_FLD_TCP_PORT_DST rule data set failed");
    2439                 :          0 :                         return -1;
    2440                 :            :                 }
    2441                 :            : 
    2442                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    2443                 :            :                                 &priv->extract.tc_key_extract[group],
    2444                 :            :                                 &flow->fs_rule,
    2445                 :            :                                 NET_PROT_TCP,
    2446                 :            :                                 NH_FLD_TCP_PORT_DST,
    2447                 :            :                                 &spec->hdr.dst_port,
    2448                 :            :                                 &mask->hdr.dst_port,
    2449                 :            :                                 NH_FLD_TCP_PORT_SIZE);
    2450         [ #  # ]:          0 :                 if (ret) {
    2451                 :          0 :                         DPAA2_PMD_ERR(
    2452                 :            :                                 "FS NH_FLD_TCP_PORT_DST rule data set failed");
    2453                 :          0 :                         return -1;
    2454                 :            :                 }
    2455                 :            :         }
    2456                 :            : 
    2457                 :          0 :         (*device_configured) |= local_cfg;
    2458                 :            : 
    2459                 :          0 :         return 0;
    2460                 :            : }
    2461                 :            : 
    2462                 :            : static int
    2463                 :          0 : dpaa2_configure_flow_sctp(struct rte_flow *flow,
    2464                 :            :                           struct rte_eth_dev *dev,
    2465                 :            :                           const struct rte_flow_attr *attr,
    2466                 :            :                           const struct rte_flow_item *pattern,
    2467                 :            :                           const struct rte_flow_action actions[] __rte_unused,
    2468                 :            :                           struct rte_flow_error *error __rte_unused,
    2469                 :            :                           int *device_configured)
    2470                 :            : {
    2471                 :            :         int index, ret;
    2472                 :            :         int local_cfg = 0;
    2473                 :            :         uint32_t group;
    2474                 :            :         const struct rte_flow_item_sctp *spec, *mask;
    2475                 :            : 
    2476                 :            :         const struct rte_flow_item_sctp *last __rte_unused;
    2477                 :          0 :         struct dpaa2_dev_priv *priv = dev->data->dev_private;
    2478                 :            : 
    2479                 :          0 :         group = attr->group;
    2480                 :            : 
    2481                 :            :         /* Parse pattern list to get the matching parameters */
    2482                 :          0 :         spec    = (const struct rte_flow_item_sctp *)pattern->spec;
    2483                 :            :         last    = (const struct rte_flow_item_sctp *)pattern->last;
    2484                 :          0 :         mask    = (const struct rte_flow_item_sctp *)
    2485         [ #  # ]:          0 :                         (pattern->mask ? pattern->mask :
    2486                 :            :                                 &dpaa2_flow_item_sctp_mask);
    2487                 :            : 
    2488                 :            :         /* Get traffic class index and flow id to be configured */
    2489                 :          0 :         flow->tc_id = group;
    2490                 :          0 :         flow->tc_index = attr->priority;
    2491                 :            : 
    2492   [ #  #  #  # ]:          0 :         if (!spec || !mc_l4_port_identification) {
    2493                 :            :                 struct proto_discrimination proto;
    2494                 :            : 
    2495                 :            :                 index = dpaa2_flow_extract_search(
    2496                 :            :                                 &priv->extract.qos_key_extract.dpkg,
    2497                 :            :                                 NET_PROT_IP, NH_FLD_IP_PROTO);
    2498         [ #  # ]:          0 :                 if (index < 0) {
    2499                 :          0 :                         ret = dpaa2_flow_proto_discrimination_extract(
    2500                 :            :                                         &priv->extract.qos_key_extract,
    2501                 :            :                                         DPAA2_FLOW_ITEM_TYPE_GENERIC_IP);
    2502         [ #  # ]:          0 :                         if (ret) {
    2503                 :          0 :                                 DPAA2_PMD_ERR(
    2504                 :            :                                         "QoS Extract IP protocol to discriminate SCTP failed.");
    2505                 :            : 
    2506                 :          0 :                                 return -1;
    2507                 :            :                         }
    2508                 :            :                         local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
    2509                 :            :                 }
    2510                 :            : 
    2511                 :            :                 index = dpaa2_flow_extract_search(
    2512                 :            :                                 &priv->extract.tc_key_extract[group].dpkg,
    2513                 :            :                                 NET_PROT_IP, NH_FLD_IP_PROTO);
    2514         [ #  # ]:          0 :                 if (index < 0) {
    2515                 :          0 :                         ret = dpaa2_flow_proto_discrimination_extract(
    2516                 :            :                                         &priv->extract.tc_key_extract[group],
    2517                 :            :                                         DPAA2_FLOW_ITEM_TYPE_GENERIC_IP);
    2518         [ #  # ]:          0 :                         if (ret) {
    2519                 :          0 :                                 DPAA2_PMD_ERR(
    2520                 :            :                                         "FS Extract IP protocol to discriminate SCTP failed.");
    2521                 :            : 
    2522                 :          0 :                                 return -1;
    2523                 :            :                         }
    2524                 :          0 :                         local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
    2525                 :            :                 }
    2526                 :            : 
    2527                 :          0 :                 ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
    2528         [ #  # ]:          0 :                 if (ret) {
    2529                 :          0 :                         DPAA2_PMD_ERR(
    2530                 :            :                                 "Move ipaddr before SCTP discrimination set failed");
    2531                 :          0 :                         return -1;
    2532                 :            :                 }
    2533                 :            : 
    2534                 :          0 :                 proto.type = DPAA2_FLOW_ITEM_TYPE_GENERIC_IP;
    2535                 :          0 :                 proto.ip_proto = IPPROTO_SCTP;
    2536                 :          0 :                 ret = dpaa2_flow_proto_discrimination_rule(priv, flow,
    2537                 :            :                                                         proto, group);
    2538         [ #  # ]:          0 :                 if (ret) {
    2539                 :          0 :                         DPAA2_PMD_ERR("SCTP discrimination rule set failed");
    2540                 :          0 :                         return -1;
    2541                 :            :                 }
    2542                 :            : 
    2543                 :          0 :                 (*device_configured) |= local_cfg;
    2544                 :            : 
    2545         [ #  # ]:          0 :                 if (!spec)
    2546                 :            :                         return 0;
    2547                 :            :         }
    2548                 :            : 
    2549         [ #  # ]:          0 :         if (dpaa2_flow_extract_support((const uint8_t *)mask,
    2550                 :            :                 RTE_FLOW_ITEM_TYPE_SCTP)) {
    2551                 :          0 :                 DPAA2_PMD_WARN("Extract field(s) of SCTP not support.");
    2552                 :            : 
    2553                 :          0 :                 return -1;
    2554                 :            :         }
    2555                 :            : 
    2556         [ #  # ]:          0 :         if (mask->hdr.src_port) {
    2557                 :            :                 index = dpaa2_flow_extract_search(
    2558                 :            :                                 &priv->extract.qos_key_extract.dpkg,
    2559                 :            :                                 NET_PROT_SCTP, NH_FLD_SCTP_PORT_SRC);
    2560         [ #  # ]:          0 :                 if (index < 0) {
    2561                 :          0 :                         ret = dpaa2_flow_extract_add(
    2562                 :            :                                         &priv->extract.qos_key_extract,
    2563                 :            :                                         NET_PROT_SCTP,
    2564                 :            :                                         NH_FLD_SCTP_PORT_SRC,
    2565                 :            :                                         NH_FLD_SCTP_PORT_SIZE);
    2566         [ #  # ]:          0 :                         if (ret) {
    2567                 :          0 :                                 DPAA2_PMD_ERR("QoS Extract add SCTP_SRC failed.");
    2568                 :            : 
    2569                 :          0 :                                 return -1;
    2570                 :            :                         }
    2571                 :          0 :                         local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
    2572                 :            :                 }
    2573                 :            : 
    2574                 :            :                 index = dpaa2_flow_extract_search(
    2575                 :            :                                 &priv->extract.tc_key_extract[group].dpkg,
    2576                 :            :                                 NET_PROT_SCTP, NH_FLD_SCTP_PORT_SRC);
    2577         [ #  # ]:          0 :                 if (index < 0) {
    2578                 :          0 :                         ret = dpaa2_flow_extract_add(
    2579                 :            :                                         &priv->extract.tc_key_extract[group],
    2580                 :            :                                         NET_PROT_SCTP,
    2581                 :            :                                         NH_FLD_SCTP_PORT_SRC,
    2582                 :            :                                         NH_FLD_SCTP_PORT_SIZE);
    2583         [ #  # ]:          0 :                         if (ret) {
    2584                 :          0 :                                 DPAA2_PMD_ERR("FS Extract add SCTP_SRC failed.");
    2585                 :            : 
    2586                 :          0 :                                 return -1;
    2587                 :            :                         }
    2588                 :          0 :                         local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
    2589                 :            :                 }
    2590                 :            : 
    2591                 :          0 :                 ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
    2592         [ #  # ]:          0 :                 if (ret) {
    2593                 :          0 :                         DPAA2_PMD_ERR(
    2594                 :            :                                 "Move ipaddr before SCTP_PORT_SRC set failed");
    2595                 :          0 :                         return -1;
    2596                 :            :                 }
    2597                 :            : 
    2598                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    2599                 :            :                                 &priv->extract.qos_key_extract,
    2600                 :            :                                 &flow->qos_rule,
    2601                 :            :                                 NET_PROT_SCTP,
    2602                 :            :                                 NH_FLD_SCTP_PORT_SRC,
    2603                 :          0 :                                 &spec->hdr.src_port,
    2604                 :          0 :                                 &mask->hdr.src_port,
    2605                 :            :                                 NH_FLD_SCTP_PORT_SIZE);
    2606         [ #  # ]:          0 :                 if (ret) {
    2607                 :          0 :                         DPAA2_PMD_ERR(
    2608                 :            :                                 "QoS NH_FLD_SCTP_PORT_SRC rule data set failed");
    2609                 :          0 :                         return -1;
    2610                 :            :                 }
    2611                 :            : 
    2612                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    2613                 :            :                                 &priv->extract.tc_key_extract[group],
    2614                 :            :                                 &flow->fs_rule,
    2615                 :            :                                 NET_PROT_SCTP,
    2616                 :            :                                 NH_FLD_SCTP_PORT_SRC,
    2617                 :            :                                 &spec->hdr.src_port,
    2618                 :            :                                 &mask->hdr.src_port,
    2619                 :            :                                 NH_FLD_SCTP_PORT_SIZE);
    2620         [ #  # ]:          0 :                 if (ret) {
    2621                 :          0 :                         DPAA2_PMD_ERR(
    2622                 :            :                                 "FS NH_FLD_SCTP_PORT_SRC rule data set failed");
    2623                 :          0 :                         return -1;
    2624                 :            :                 }
    2625                 :            :         }
    2626                 :            : 
    2627         [ #  # ]:          0 :         if (mask->hdr.dst_port) {
    2628                 :            :                 index = dpaa2_flow_extract_search(
    2629                 :            :                                 &priv->extract.qos_key_extract.dpkg,
    2630                 :            :                                 NET_PROT_SCTP, NH_FLD_SCTP_PORT_DST);
    2631         [ #  # ]:          0 :                 if (index < 0) {
    2632                 :          0 :                         ret = dpaa2_flow_extract_add(
    2633                 :            :                                         &priv->extract.qos_key_extract,
    2634                 :            :                                         NET_PROT_SCTP,
    2635                 :            :                                         NH_FLD_SCTP_PORT_DST,
    2636                 :            :                                         NH_FLD_SCTP_PORT_SIZE);
    2637         [ #  # ]:          0 :                         if (ret) {
    2638                 :          0 :                                 DPAA2_PMD_ERR("QoS Extract add SCTP_DST failed.");
    2639                 :            : 
    2640                 :          0 :                                 return -1;
    2641                 :            :                         }
    2642                 :          0 :                         local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
    2643                 :            :                 }
    2644                 :            : 
    2645                 :            :                 index = dpaa2_flow_extract_search(
    2646                 :            :                                 &priv->extract.tc_key_extract[group].dpkg,
    2647                 :            :                                 NET_PROT_SCTP, NH_FLD_SCTP_PORT_DST);
    2648         [ #  # ]:          0 :                 if (index < 0) {
    2649                 :          0 :                         ret = dpaa2_flow_extract_add(
    2650                 :            :                                         &priv->extract.tc_key_extract[group],
    2651                 :            :                                         NET_PROT_SCTP,
    2652                 :            :                                         NH_FLD_SCTP_PORT_DST,
    2653                 :            :                                         NH_FLD_SCTP_PORT_SIZE);
    2654         [ #  # ]:          0 :                         if (ret) {
    2655                 :          0 :                                 DPAA2_PMD_ERR("FS Extract add SCTP_DST failed.");
    2656                 :            : 
    2657                 :          0 :                                 return -1;
    2658                 :            :                         }
    2659                 :          0 :                         local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
    2660                 :            :                 }
    2661                 :            : 
    2662                 :          0 :                 ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
    2663         [ #  # ]:          0 :                 if (ret) {
    2664                 :          0 :                         DPAA2_PMD_ERR(
    2665                 :            :                                 "Move ipaddr before SCTP_PORT_DST set failed");
    2666                 :          0 :                         return -1;
    2667                 :            :                 }
    2668                 :            : 
    2669                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    2670                 :            :                                 &priv->extract.qos_key_extract,
    2671                 :            :                                 &flow->qos_rule,
    2672                 :            :                                 NET_PROT_SCTP,
    2673                 :            :                                 NH_FLD_SCTP_PORT_DST,
    2674                 :          0 :                                 &spec->hdr.dst_port,
    2675                 :          0 :                                 &mask->hdr.dst_port,
    2676                 :            :                                 NH_FLD_SCTP_PORT_SIZE);
    2677         [ #  # ]:          0 :                 if (ret) {
    2678                 :          0 :                         DPAA2_PMD_ERR(
    2679                 :            :                                 "QoS NH_FLD_SCTP_PORT_DST rule data set failed");
    2680                 :          0 :                         return -1;
    2681                 :            :                 }
    2682                 :            : 
    2683                 :          0 :                 ret = dpaa2_flow_rule_data_set(
    2684                 :            :                                 &priv->extract.tc_key_extract[group],
    2685                 :            :                                 &flow->fs_rule,
    2686                 :            :                                 NET_PROT_SCTP,
    2687                 :            :                                 NH_FLD_SCTP_PORT_DST,
    2688                 :            :                                 &spec->hdr.dst_port,
    2689                 :            :                                 &mask->hdr.dst_port,
    2690                 :            :                                 NH_FLD_SCTP_PORT_SIZE);
    2691         [ #  # ]:          0 :                 if (ret) {
    2692                 :          0 :                         DPAA2_PMD_ERR(
    2693                 :            :                                 "FS NH_FLD_SCTP_PORT_DST rule data set failed");
    2694                 :          0 :                         return -1;
    2695                 :            :                 }
    2696                 :            :         }
    2697                 :            : 
    2698                 :          0 :         (*device_configured) |= local_cfg;
    2699                 :            : 
    2700                 :          0 :         return 0;
    2701                 :            : }
    2702                 :            : 
    2703                 :            : static int
    2704                 :          0 : dpaa2_configure_flow_gre(struct rte_flow *flow,
    2705                 :            :                          struct rte_eth_dev *dev,
    2706                 :            :                          const struct rte_flow_attr *attr,
    2707                 :            :                          const struct rte_flow_item *pattern,
    2708                 :            :                          const struct rte_flow_action actions[] __rte_unused,
    2709                 :            :                          struct rte_flow_error *error __rte_unused,
    2710                 :            :                          int *device_configured)
    2711                 :            : {
    2712                 :            :         int index, ret;
    2713                 :            :         int local_cfg = 0;
    2714                 :            :         uint32_t group;
    2715                 :            :         const struct rte_flow_item_gre *spec, *mask;
    2716                 :            : 
    2717                 :            :         const struct rte_flow_item_gre *last __rte_unused;
    2718                 :          0 :         struct dpaa2_dev_priv *priv = dev->data->dev_private;
    2719                 :            : 
    2720                 :          0 :         group = attr->group;
    2721                 :            : 
    2722                 :            :         /* Parse pattern list to get the matching parameters */
    2723                 :          0 :         spec    = (const struct rte_flow_item_gre *)pattern->spec;
    2724                 :            :         last    = (const struct rte_flow_item_gre *)pattern->last;
    2725                 :          0 :         mask    = (const struct rte_flow_item_gre *)
    2726         [ #  # ]:          0 :                 (pattern->mask ? pattern->mask : &dpaa2_flow_item_gre_mask);
    2727                 :            : 
    2728                 :            :         /* Get traffic class index and flow id to be configured */
    2729                 :          0 :         flow->tc_id = group;
    2730                 :          0 :         flow->tc_index = attr->priority;
    2731                 :            : 
    2732         [ #  # ]:          0 :         if (!spec) {
    2733                 :            :                 struct proto_discrimination proto;
    2734                 :            : 
    2735                 :            :                 index = dpaa2_flow_extract_search(
    2736                 :            :                                 &priv->extract.qos_key_extract.dpkg,
    2737                 :            :                                 NET_PROT_IP, NH_FLD_IP_PROTO);
    2738         [ #  # ]:          0 :                 if (index < 0) {
    2739                 :          0 :                         ret = dpaa2_flow_proto_discrimination_extract(
    2740                 :            :                                         &priv->extract.qos_key_extract,
    2741                 :            :                                         DPAA2_FLOW_ITEM_TYPE_GENERIC_IP);
    2742         [ #  # ]:          0 :                         if (ret) {
    2743                 :          0 :                                 DPAA2_PMD_ERR(
    2744                 :            :                                         "QoS Extract IP protocol to discriminate GRE failed.");
    2745                 :            : 
    2746                 :          0 :                                 return -1;
    2747                 :            :                         }
    2748                 :            :                         local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
    2749                 :            :                 }
    2750                 :            : 
    2751                 :            :                 index = dpaa2_flow_extract_search(
    2752                 :            :                                 &priv->extract.tc_key_extract[group].dpkg,
    2753                 :            :                                 NET_PROT_IP, NH_FLD_IP_PROTO);
    2754         [ #  # ]:          0 :                 if (index < 0) {
    2755                 :          0 :                         ret = dpaa2_flow_proto_discrimination_extract(
    2756                 :            :                                         &priv->extract.tc_key_extract[group],
    2757                 :            :                                         DPAA2_FLOW_ITEM_TYPE_GENERIC_IP);
    2758         [ #  # ]:          0 :                         if (ret) {
    2759                 :          0 :                                 DPAA2_PMD_ERR(
    2760                 :            :                                         "FS Extract IP protocol to discriminate GRE failed.");
    2761                 :            : 
    2762                 :          0 :                                 return -1;
    2763                 :            :                         }
    2764                 :          0 :                         local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
    2765                 :            :                 }
    2766                 :            : 
    2767                 :          0 :                 ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
    2768         [ #  # ]:          0 :                 if (ret) {
    2769                 :          0 :                         DPAA2_PMD_ERR(
    2770                 :            :                                 "Move IP addr before GRE discrimination set failed");
    2771                 :          0 :                         return -1;
    2772                 :            :                 }
    2773                 :            : 
    2774                 :          0 :                 proto.type = DPAA2_FLOW_ITEM_TYPE_GENERIC_IP;
    2775                 :          0 :                 proto.ip_proto = IPPROTO_GRE;
    2776                 :          0 :                 ret = dpaa2_flow_proto_discrimination_rule(priv, flow,
    2777                 :            :                                                         proto, group);
    2778         [ #  # ]:          0 :                 if (ret) {
    2779                 :          0 :                         DPAA2_PMD_ERR("GRE discrimination rule set failed");
    2780                 :          0 :                         return -1;
    2781                 :            :                 }
    2782                 :            : 
    2783                 :          0 :                 (*device_configured) |= local_cfg;
    2784                 :            : 
    2785                 :          0 :                 return 0;
    2786                 :            :         }
    2787                 :            : 
    2788         [ #  # ]:          0 :         if (dpaa2_flow_extract_support((const uint8_t *)mask,
    2789                 :            :                 RTE_FLOW_ITEM_TYPE_GRE)) {
    2790                 :          0 :                 DPAA2_PMD_WARN("Extract field(s) of GRE not support.");
    2791                 :            : 
    2792                 :          0 :                 return -1;
    2793                 :            :         }
    2794                 :            : 
    2795         [ #  # ]:          0 :         if (!mask->protocol)
    2796                 :            :                 return 0;
    2797                 :            : 
    2798                 :            :         index = dpaa2_flow_extract_search(
    2799                 :            :                         &priv->extract.qos_key_extract.dpkg,
    2800                 :            :                         NET_PROT_GRE, NH_FLD_GRE_TYPE);
    2801         [ #  # ]:          0 :         if (index < 0) {
    2802                 :          0 :                 ret = dpaa2_flow_extract_add(
    2803                 :            :                                 &priv->extract.qos_key_extract,
    2804                 :            :                                 NET_PROT_GRE,
    2805                 :            :                                 NH_FLD_GRE_TYPE,
    2806                 :            :                                 sizeof(rte_be16_t));
    2807         [ #  # ]:          0 :                 if (ret) {
    2808                 :          0 :                         DPAA2_PMD_ERR("QoS Extract add GRE_TYPE failed.");
    2809                 :            : 
    2810                 :          0 :                         return -1;
    2811                 :            :                 }
    2812                 :            :                 local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
    2813                 :            :         }
    2814                 :            : 
    2815                 :            :         index = dpaa2_flow_extract_search(
    2816                 :            :                         &priv->extract.tc_key_extract[group].dpkg,
    2817                 :            :                         NET_PROT_GRE, NH_FLD_GRE_TYPE);
    2818         [ #  # ]:          0 :         if (index < 0) {
    2819                 :          0 :                 ret = dpaa2_flow_extract_add(
    2820                 :            :                                 &priv->extract.tc_key_extract[group],
    2821                 :            :                                 NET_PROT_GRE,
    2822                 :            :                                 NH_FLD_GRE_TYPE,
    2823                 :            :                                 sizeof(rte_be16_t));
    2824         [ #  # ]:          0 :                 if (ret) {
    2825                 :          0 :                         DPAA2_PMD_ERR("FS Extract add GRE_TYPE failed.");
    2826                 :            : 
    2827                 :          0 :                         return -1;
    2828                 :            :                 }
    2829                 :          0 :                 local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
    2830                 :            :         }
    2831                 :            : 
    2832                 :          0 :         ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
    2833         [ #  # ]:          0 :         if (ret) {
    2834                 :          0 :                 DPAA2_PMD_ERR(
    2835                 :            :                         "Move ipaddr before GRE_TYPE set failed");
    2836                 :          0 :                 return -1;
    2837                 :            :         }
    2838                 :            : 
    2839                 :          0 :         ret = dpaa2_flow_rule_data_set(
    2840                 :            :                                 &priv->extract.qos_key_extract,
    2841                 :            :                                 &flow->qos_rule,
    2842                 :            :                                 NET_PROT_GRE,
    2843                 :            :                                 NH_FLD_GRE_TYPE,
    2844                 :          0 :                                 &spec->protocol,
    2845                 :          0 :                                 &mask->protocol,
    2846                 :            :                                 sizeof(rte_be16_t));
    2847         [ #  # ]:          0 :         if (ret) {
    2848                 :          0 :                 DPAA2_PMD_ERR(
    2849                 :            :                         "QoS NH_FLD_GRE_TYPE rule data set failed");
    2850                 :          0 :                 return -1;
    2851                 :            :         }
    2852                 :            : 
    2853                 :          0 :         ret = dpaa2_flow_rule_data_set(
    2854                 :            :                         &priv->extract.tc_key_extract[group],
    2855                 :            :                         &flow->fs_rule,
    2856                 :            :                         NET_PROT_GRE,
    2857                 :            :                         NH_FLD_GRE_TYPE,
    2858                 :            :                         &spec->protocol,
    2859                 :            :                         &mask->protocol,
    2860                 :            :                         sizeof(rte_be16_t));
    2861         [ #  # ]:          0 :         if (ret) {
    2862                 :          0 :                 DPAA2_PMD_ERR(
    2863                 :            :                         "FS NH_FLD_GRE_TYPE rule data set failed");
    2864                 :          0 :                 return -1;
    2865                 :            :         }
    2866                 :            : 
    2867                 :          0 :         (*device_configured) |= local_cfg;
    2868                 :            : 
    2869                 :          0 :         return 0;
    2870                 :            : }
    2871                 :            : 
    2872                 :            : static int
    2873                 :          0 : dpaa2_configure_flow_raw(struct rte_flow *flow,
    2874                 :            :                          struct rte_eth_dev *dev,
    2875                 :            :                          const struct rte_flow_attr *attr,
    2876                 :            :                          const struct rte_flow_item *pattern,
    2877                 :            :                          const struct rte_flow_action actions[] __rte_unused,
    2878                 :            :                          struct rte_flow_error *error __rte_unused,
    2879                 :            :                          int *device_configured)
    2880                 :            : {
    2881                 :          0 :         struct dpaa2_dev_priv *priv = dev->data->dev_private;
    2882                 :          0 :         const struct rte_flow_item_raw *spec = pattern->spec;
    2883                 :          0 :         const struct rte_flow_item_raw *mask = pattern->mask;
    2884                 :            :         int prev_key_size =
    2885                 :          0 :                 priv->extract.qos_key_extract.key_info.key_total_size;
    2886                 :            :         int local_cfg = 0, ret;
    2887                 :            :         uint32_t group;
    2888                 :            : 
    2889                 :            :         /* Need both spec and mask */
    2890         [ #  # ]:          0 :         if (!spec || !mask) {
    2891                 :          0 :                 DPAA2_PMD_ERR("spec or mask not present.");
    2892                 :          0 :                 return -EINVAL;
    2893                 :            :         }
    2894                 :            :         /* Only supports non-relative with offset 0 */
    2895         [ #  # ]:          0 :         if (spec->relative || spec->offset != 0 ||
    2896         [ #  # ]:          0 :             spec->search || spec->limit) {
    2897                 :          0 :                 DPAA2_PMD_ERR("relative and non zero offset not supported.");
    2898                 :          0 :                 return -EINVAL;
    2899                 :            :         }
    2900                 :            :         /* Spec len and mask len should be same */
    2901         [ #  # ]:          0 :         if (spec->length != mask->length) {
    2902                 :          0 :                 DPAA2_PMD_ERR("Spec len and mask len mismatch.");
    2903                 :          0 :                 return -EINVAL;
    2904                 :            :         }
    2905                 :            : 
    2906                 :            :         /* Get traffic class index and flow id to be configured */
    2907                 :          0 :         group = attr->group;
    2908                 :          0 :         flow->tc_id = group;
    2909                 :          0 :         flow->tc_index = attr->priority;
    2910                 :            : 
    2911         [ #  # ]:          0 :         if (prev_key_size <= spec->length) {
    2912                 :          0 :                 ret = dpaa2_flow_extract_add_raw(&priv->extract.qos_key_extract,
    2913                 :            :                                                  spec->length);
    2914         [ #  # ]:          0 :                 if (ret) {
    2915                 :          0 :                         DPAA2_PMD_ERR("QoS Extract RAW add failed.");
    2916                 :          0 :                         return -1;
    2917                 :            :                 }
    2918                 :            :                 local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
    2919                 :            : 
    2920                 :          0 :                 ret = dpaa2_flow_extract_add_raw(
    2921                 :            :                                         &priv->extract.tc_key_extract[group],
    2922                 :          0 :                                         spec->length);
    2923         [ #  # ]:          0 :                 if (ret) {
    2924                 :          0 :                         DPAA2_PMD_ERR("FS Extract RAW add failed.");
    2925                 :          0 :                         return -1;
    2926                 :            :                 }
    2927                 :            :                 local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
    2928                 :            :         }
    2929                 :            : 
    2930                 :          0 :         ret = dpaa2_flow_rule_data_set_raw(&flow->qos_rule, spec->pattern,
    2931                 :          0 :                                            mask->pattern, spec->length);
    2932         [ #  # ]:          0 :         if (ret) {
    2933                 :          0 :                 DPAA2_PMD_ERR("QoS RAW rule data set failed");
    2934                 :          0 :                 return -1;
    2935                 :            :         }
    2936                 :            : 
    2937                 :          0 :         ret = dpaa2_flow_rule_data_set_raw(&flow->fs_rule, spec->pattern,
    2938                 :          0 :                                            mask->pattern, spec->length);
    2939         [ #  # ]:          0 :         if (ret) {
    2940                 :          0 :                 DPAA2_PMD_ERR("FS RAW rule data set failed");
    2941                 :          0 :                 return -1;
    2942                 :            :         }
    2943                 :            : 
    2944                 :          0 :         (*device_configured) |= local_cfg;
    2945                 :            : 
    2946                 :          0 :         return 0;
    2947                 :            : }
    2948                 :            : 
    2949                 :            : static inline int
    2950                 :            : dpaa2_fs_action_supported(enum rte_flow_action_type action)
    2951                 :            : {
    2952                 :            :         int i;
    2953                 :            : 
    2954         [ #  # ]:          0 :         for (i = 0; i < (int)(sizeof(dpaa2_supported_fs_action_type) /
    2955                 :          0 :                                         sizeof(enum rte_flow_action_type)); i++) {
    2956         [ #  # ]:          0 :                 if (action == dpaa2_supported_fs_action_type[i])
    2957                 :            :                         return 1;
    2958                 :            :         }
    2959                 :            : 
    2960                 :            :         return 0;
    2961                 :            : }
    2962                 :            : /* The existing QoS/FS entry with IP address(es)
    2963                 :            :  * needs update after
    2964                 :            :  * new extract(s) are inserted before IP
    2965                 :            :  * address(es) extract(s).
    2966                 :            :  */
    2967                 :            : static int
    2968                 :          0 : dpaa2_flow_entry_update(
    2969                 :            :         struct dpaa2_dev_priv *priv, uint8_t tc_id)
    2970                 :            : {
    2971                 :          0 :         struct rte_flow *curr = LIST_FIRST(&priv->flows);
    2972                 :          0 :         struct fsl_mc_io *dpni = (struct fsl_mc_io *)priv->hw;
    2973                 :            :         int ret;
    2974                 :            :         int qos_ipsrc_offset = -1, qos_ipdst_offset = -1;
    2975                 :            :         int fs_ipsrc_offset = -1, fs_ipdst_offset = -1;
    2976                 :            :         struct dpaa2_key_extract *qos_key_extract =
    2977                 :            :                 &priv->extract.qos_key_extract;
    2978                 :            :         struct dpaa2_key_extract *tc_key_extract =
    2979                 :          0 :                 &priv->extract.tc_key_extract[tc_id];
    2980                 :            :         char ipsrc_key[NH_FLD_IPV6_ADDR_SIZE];
    2981                 :            :         char ipdst_key[NH_FLD_IPV6_ADDR_SIZE];
    2982                 :            :         char ipsrc_mask[NH_FLD_IPV6_ADDR_SIZE];
    2983                 :            :         char ipdst_mask[NH_FLD_IPV6_ADDR_SIZE];
    2984                 :            :         int extend = -1, extend1, size = -1;
    2985                 :            :         uint16_t qos_index;
    2986                 :            : 
    2987         [ #  # ]:          0 :         while (curr) {
    2988         [ #  # ]:          0 :                 if (curr->ipaddr_rule.ipaddr_type ==
    2989                 :            :                         FLOW_NONE_IPADDR) {
    2990                 :          0 :                         curr = LIST_NEXT(curr, next);
    2991                 :          0 :                         continue;
    2992                 :            :                 }
    2993                 :            : 
    2994         [ #  # ]:          0 :                 if (curr->ipaddr_rule.ipaddr_type ==
    2995                 :            :                         FLOW_IPV4_ADDR) {
    2996                 :          0 :                         qos_ipsrc_offset =
    2997                 :            :                                 qos_key_extract->key_info.ipv4_src_offset;
    2998                 :          0 :                         qos_ipdst_offset =
    2999                 :            :                                 qos_key_extract->key_info.ipv4_dst_offset;
    3000                 :          0 :                         fs_ipsrc_offset =
    3001                 :            :                                 tc_key_extract->key_info.ipv4_src_offset;
    3002                 :          0 :                         fs_ipdst_offset =
    3003                 :            :                                 tc_key_extract->key_info.ipv4_dst_offset;
    3004                 :            :                         size = NH_FLD_IPV4_ADDR_SIZE;
    3005                 :            :                 } else {
    3006                 :          0 :                         qos_ipsrc_offset =
    3007                 :            :                                 qos_key_extract->key_info.ipv6_src_offset;
    3008                 :          0 :                         qos_ipdst_offset =
    3009                 :            :                                 qos_key_extract->key_info.ipv6_dst_offset;
    3010                 :          0 :                         fs_ipsrc_offset =
    3011                 :            :                                 tc_key_extract->key_info.ipv6_src_offset;
    3012                 :          0 :                         fs_ipdst_offset =
    3013                 :            :                                 tc_key_extract->key_info.ipv6_dst_offset;
    3014                 :            :                         size = NH_FLD_IPV6_ADDR_SIZE;
    3015                 :            :                 }
    3016                 :            : 
    3017                 :          0 :                 qos_index = curr->tc_id * priv->fs_entries +
    3018                 :          0 :                         curr->tc_index;
    3019                 :            : 
    3020                 :          0 :                 dpaa2_flow_qos_entry_log("Before update", curr, qos_index);
    3021                 :            : 
    3022         [ #  # ]:          0 :                 if (priv->num_rx_tc > 1) {
    3023                 :          0 :                         ret = dpni_remove_qos_entry(dpni, CMD_PRI_LOW,
    3024                 :          0 :                                         priv->token, &curr->qos_rule);
    3025         [ #  # ]:          0 :                         if (ret) {
    3026                 :          0 :                                 DPAA2_PMD_ERR("Qos entry remove failed.");
    3027                 :          0 :                                 return -1;
    3028                 :            :                         }
    3029                 :            :                 }
    3030                 :            : 
    3031                 :            :                 extend = -1;
    3032                 :            : 
    3033         [ #  # ]:          0 :                 if (curr->ipaddr_rule.qos_ipsrc_offset >= 0) {
    3034                 :            :                         RTE_ASSERT(qos_ipsrc_offset >=
    3035                 :            :                                 curr->ipaddr_rule.qos_ipsrc_offset);
    3036                 :          0 :                         extend1 = qos_ipsrc_offset -
    3037                 :            :                                 curr->ipaddr_rule.qos_ipsrc_offset;
    3038                 :            :                         if (extend >= 0)
    3039                 :            :                                 RTE_ASSERT(extend == extend1);
    3040                 :            :                         else
    3041                 :            :                                 extend = extend1;
    3042                 :            : 
    3043                 :            :                         RTE_ASSERT((size == NH_FLD_IPV4_ADDR_SIZE) ||
    3044                 :            :                                 (size == NH_FLD_IPV6_ADDR_SIZE));
    3045                 :            : 
    3046                 :          0 :                         memcpy(ipsrc_key,
    3047                 :          0 :                                 (char *)(size_t)curr->qos_rule.key_iova +
    3048                 :          0 :                                 curr->ipaddr_rule.qos_ipsrc_offset,
    3049                 :            :                                 size);
    3050                 :            :                         memset((char *)(size_t)curr->qos_rule.key_iova +
    3051                 :            :                                 curr->ipaddr_rule.qos_ipsrc_offset,
    3052                 :            :                                 0, size);
    3053                 :            : 
    3054                 :          0 :                         memcpy(ipsrc_mask,
    3055                 :          0 :                                 (char *)(size_t)curr->qos_rule.mask_iova +
    3056                 :          0 :                                 curr->ipaddr_rule.qos_ipsrc_offset,
    3057                 :            :                                 size);
    3058                 :            :                         memset((char *)(size_t)curr->qos_rule.mask_iova +
    3059                 :            :                                 curr->ipaddr_rule.qos_ipsrc_offset,
    3060                 :            :                                 0, size);
    3061                 :            : 
    3062                 :          0 :                         curr->ipaddr_rule.qos_ipsrc_offset = qos_ipsrc_offset;
    3063                 :            :                 }
    3064                 :            : 
    3065         [ #  # ]:          0 :                 if (curr->ipaddr_rule.qos_ipdst_offset >= 0) {
    3066                 :            :                         RTE_ASSERT(qos_ipdst_offset >=
    3067                 :            :                                 curr->ipaddr_rule.qos_ipdst_offset);
    3068                 :          0 :                         extend1 = qos_ipdst_offset -
    3069                 :            :                                 curr->ipaddr_rule.qos_ipdst_offset;
    3070         [ #  # ]:          0 :                         if (extend >= 0)
    3071                 :            :                                 RTE_ASSERT(extend == extend1);
    3072                 :            :                         else
    3073                 :            :                                 extend = extend1;
    3074                 :            : 
    3075                 :            :                         RTE_ASSERT((size == NH_FLD_IPV4_ADDR_SIZE) ||
    3076                 :            :                                 (size == NH_FLD_IPV6_ADDR_SIZE));
    3077                 :            : 
    3078                 :          0 :                         memcpy(ipdst_key,
    3079                 :          0 :                                 (char *)(size_t)curr->qos_rule.key_iova +
    3080                 :          0 :                                 curr->ipaddr_rule.qos_ipdst_offset,
    3081                 :            :                                 size);
    3082                 :            :                         memset((char *)(size_t)curr->qos_rule.key_iova +
    3083                 :            :                                 curr->ipaddr_rule.qos_ipdst_offset,
    3084                 :            :                                 0, size);
    3085                 :            : 
    3086                 :          0 :                         memcpy(ipdst_mask,
    3087                 :          0 :                                 (char *)(size_t)curr->qos_rule.mask_iova +
    3088                 :          0 :                                 curr->ipaddr_rule.qos_ipdst_offset,
    3089                 :            :                                 size);
    3090                 :            :                         memset((char *)(size_t)curr->qos_rule.mask_iova +
    3091                 :            :                                 curr->ipaddr_rule.qos_ipdst_offset,
    3092                 :            :                                 0, size);
    3093                 :            : 
    3094                 :          0 :                         curr->ipaddr_rule.qos_ipdst_offset = qos_ipdst_offset;
    3095                 :            :                 }
    3096                 :            : 
    3097         [ #  # ]:          0 :                 if (curr->ipaddr_rule.qos_ipsrc_offset >= 0) {
    3098                 :            :                         RTE_ASSERT((size == NH_FLD_IPV4_ADDR_SIZE) ||
    3099                 :            :                                 (size == NH_FLD_IPV6_ADDR_SIZE));
    3100                 :          0 :                         memcpy((char *)(size_t)curr->qos_rule.key_iova +
    3101                 :          0 :                                 curr->ipaddr_rule.qos_ipsrc_offset,
    3102                 :            :                                 ipsrc_key,
    3103                 :            :                                 size);
    3104                 :          0 :                         memcpy((char *)(size_t)curr->qos_rule.mask_iova +
    3105                 :          0 :                                 curr->ipaddr_rule.qos_ipsrc_offset,
    3106                 :            :                                 ipsrc_mask,
    3107                 :            :                                 size);
    3108                 :            :                 }
    3109         [ #  # ]:          0 :                 if (curr->ipaddr_rule.qos_ipdst_offset >= 0) {
    3110                 :            :                         RTE_ASSERT((size == NH_FLD_IPV4_ADDR_SIZE) ||
    3111                 :            :                                 (size == NH_FLD_IPV6_ADDR_SIZE));
    3112                 :          0 :                         memcpy((char *)(size_t)curr->qos_rule.key_iova +
    3113                 :          0 :                                 curr->ipaddr_rule.qos_ipdst_offset,
    3114                 :            :                                 ipdst_key,
    3115                 :            :                                 size);
    3116                 :          0 :                         memcpy((char *)(size_t)curr->qos_rule.mask_iova +
    3117                 :          0 :                                 curr->ipaddr_rule.qos_ipdst_offset,
    3118                 :            :                                 ipdst_mask,
    3119                 :            :                                 size);
    3120                 :            :                 }
    3121                 :            : 
    3122         [ #  # ]:          0 :                 if (extend >= 0)
    3123                 :          0 :                         curr->qos_real_key_size += extend;
    3124                 :            : 
    3125                 :          0 :                 curr->qos_rule.key_size = FIXED_ENTRY_SIZE;
    3126                 :            : 
    3127                 :          0 :                 dpaa2_flow_qos_entry_log("Start update", curr, qos_index);
    3128                 :            : 
    3129         [ #  # ]:          0 :                 if (priv->num_rx_tc > 1) {
    3130                 :          0 :                         ret = dpni_add_qos_entry(dpni, CMD_PRI_LOW,
    3131                 :          0 :                                         priv->token, &curr->qos_rule,
    3132                 :          0 :                                         curr->tc_id, qos_index,
    3133                 :            :                                         0, 0);
    3134         [ #  # ]:          0 :                         if (ret) {
    3135                 :          0 :                                 DPAA2_PMD_ERR("Qos entry update failed.");
    3136                 :          0 :                                 return -1;
    3137                 :            :                         }
    3138                 :            :                 }
    3139                 :            : 
    3140         [ #  # ]:          0 :                 if (!dpaa2_fs_action_supported(curr->action)) {
    3141                 :          0 :                         curr = LIST_NEXT(curr, next);
    3142                 :          0 :                         continue;
    3143                 :            :                 }
    3144                 :            : 
    3145                 :          0 :                 dpaa2_flow_fs_entry_log("Before update", curr);
    3146                 :            :                 extend = -1;
    3147                 :            : 
    3148                 :          0 :                 ret = dpni_remove_fs_entry(dpni, CMD_PRI_LOW,
    3149                 :          0 :                                 priv->token, curr->tc_id, &curr->fs_rule);
    3150         [ #  # ]:          0 :                 if (ret) {
    3151                 :          0 :                         DPAA2_PMD_ERR("FS entry remove failed.");
    3152                 :          0 :                         return -1;
    3153                 :            :                 }
    3154                 :            : 
    3155         [ #  # ]:          0 :                 if (curr->ipaddr_rule.fs_ipsrc_offset >= 0 &&
    3156         [ #  # ]:          0 :                         tc_id == curr->tc_id) {
    3157                 :            :                         RTE_ASSERT(fs_ipsrc_offset >=
    3158                 :            :                                 curr->ipaddr_rule.fs_ipsrc_offset);
    3159                 :          0 :                         extend1 = fs_ipsrc_offset -
    3160                 :            :                                 curr->ipaddr_rule.fs_ipsrc_offset;
    3161                 :            :                         if (extend >= 0)
    3162                 :            :                                 RTE_ASSERT(extend == extend1);
    3163                 :            :                         else
    3164                 :            :                                 extend = extend1;
    3165                 :            : 
    3166                 :          0 :                         memcpy(ipsrc_key,
    3167                 :          0 :                                 (char *)(size_t)curr->fs_rule.key_iova +
    3168                 :          0 :                                 curr->ipaddr_rule.fs_ipsrc_offset,
    3169                 :            :                                 size);
    3170                 :            :                         memset((char *)(size_t)curr->fs_rule.key_iova +
    3171                 :            :                                 curr->ipaddr_rule.fs_ipsrc_offset,
    3172                 :            :                                 0, size);
    3173                 :            : 
    3174                 :          0 :                         memcpy(ipsrc_mask,
    3175                 :          0 :                                 (char *)(size_t)curr->fs_rule.mask_iova +
    3176                 :          0 :                                 curr->ipaddr_rule.fs_ipsrc_offset,
    3177                 :            :                                 size);
    3178                 :            :                         memset((char *)(size_t)curr->fs_rule.mask_iova +
    3179                 :            :                                 curr->ipaddr_rule.fs_ipsrc_offset,
    3180                 :            :                                 0, size);
    3181                 :            : 
    3182                 :          0 :                         curr->ipaddr_rule.fs_ipsrc_offset = fs_ipsrc_offset;
    3183                 :            :                 }
    3184                 :            : 
    3185         [ #  # ]:          0 :                 if (curr->ipaddr_rule.fs_ipdst_offset >= 0 &&
    3186         [ #  # ]:          0 :                         tc_id == curr->tc_id) {
    3187                 :            :                         RTE_ASSERT(fs_ipdst_offset >=
    3188                 :            :                                 curr->ipaddr_rule.fs_ipdst_offset);
    3189                 :          0 :                         extend1 = fs_ipdst_offset -
    3190                 :            :                                 curr->ipaddr_rule.fs_ipdst_offset;
    3191         [ #  # ]:          0 :                         if (extend >= 0)
    3192                 :            :                                 RTE_ASSERT(extend == extend1);
    3193                 :            :                         else
    3194                 :            :                                 extend = extend1;
    3195                 :            : 
    3196                 :          0 :                         memcpy(ipdst_key,
    3197                 :          0 :                                 (char *)(size_t)curr->fs_rule.key_iova +
    3198                 :          0 :                                 curr->ipaddr_rule.fs_ipdst_offset,
    3199                 :            :                                 size);
    3200                 :            :                         memset((char *)(size_t)curr->fs_rule.key_iova +
    3201                 :            :                                 curr->ipaddr_rule.fs_ipdst_offset,
    3202                 :            :                                 0, size);
    3203                 :            : 
    3204                 :          0 :                         memcpy(ipdst_mask,
    3205                 :          0 :                                 (char *)(size_t)curr->fs_rule.mask_iova +
    3206                 :          0 :                                 curr->ipaddr_rule.fs_ipdst_offset,
    3207                 :            :                                 size);
    3208                 :            :                         memset((char *)(size_t)curr->fs_rule.mask_iova +
    3209                 :            :                                 curr->ipaddr_rule.fs_ipdst_offset,
    3210                 :            :                                 0, size);
    3211                 :            : 
    3212                 :          0 :                         curr->ipaddr_rule.fs_ipdst_offset = fs_ipdst_offset;
    3213                 :            :                 }
    3214                 :            : 
    3215         [ #  # ]:          0 :                 if (curr->ipaddr_rule.fs_ipsrc_offset >= 0) {
    3216                 :          0 :                         memcpy((char *)(size_t)curr->fs_rule.key_iova +
    3217                 :          0 :                                 curr->ipaddr_rule.fs_ipsrc_offset,
    3218                 :            :                                 ipsrc_key,
    3219                 :            :                                 size);
    3220                 :          0 :                         memcpy((char *)(size_t)curr->fs_rule.mask_iova +
    3221                 :          0 :                                 curr->ipaddr_rule.fs_ipsrc_offset,
    3222                 :            :                                 ipsrc_mask,
    3223                 :            :                                 size);
    3224                 :            :                 }
    3225         [ #  # ]:          0 :                 if (curr->ipaddr_rule.fs_ipdst_offset >= 0) {
    3226                 :          0 :                         memcpy((char *)(size_t)curr->fs_rule.key_iova +
    3227                 :          0 :                                 curr->ipaddr_rule.fs_ipdst_offset,
    3228                 :            :                                 ipdst_key,
    3229                 :            :                                 size);
    3230                 :          0 :                         memcpy((char *)(size_t)curr->fs_rule.mask_iova +
    3231                 :          0 :                                 curr->ipaddr_rule.fs_ipdst_offset,
    3232                 :            :                                 ipdst_mask,
    3233                 :            :                                 size);
    3234                 :            :                 }
    3235                 :            : 
    3236         [ #  # ]:          0 :                 if (extend >= 0)
    3237                 :          0 :                         curr->fs_real_key_size += extend;
    3238                 :          0 :                 curr->fs_rule.key_size = FIXED_ENTRY_SIZE;
    3239                 :            : 
    3240                 :          0 :                 dpaa2_flow_fs_entry_log("Start update", curr);
    3241                 :            : 
    3242                 :          0 :                 ret = dpni_add_fs_entry(dpni, CMD_PRI_LOW,
    3243                 :          0 :                                 priv->token, curr->tc_id, curr->tc_index,
    3244                 :          0 :                                 &curr->fs_rule, &curr->action_cfg);
    3245         [ #  # ]:          0 :                 if (ret) {
    3246                 :          0 :                         DPAA2_PMD_ERR("FS entry update failed.");
    3247                 :          0 :                         return -1;
    3248                 :            :                 }
    3249                 :            : 
    3250                 :          0 :                 curr = LIST_NEXT(curr, next);
    3251                 :            :         }
    3252                 :            : 
    3253                 :            :         return 0;
    3254                 :            : }
    3255                 :            : 
    3256                 :            : static inline int
    3257                 :          0 : dpaa2_flow_verify_attr(
    3258                 :            :         struct dpaa2_dev_priv *priv,
    3259                 :            :         const struct rte_flow_attr *attr)
    3260                 :            : {
    3261                 :          0 :         struct rte_flow *curr = LIST_FIRST(&priv->flows);
    3262                 :            : 
    3263         [ #  # ]:          0 :         while (curr) {
    3264         [ #  # ]:          0 :                 if (curr->tc_id == attr->group &&
    3265         [ #  # ]:          0 :                         curr->tc_index == attr->priority) {
    3266                 :          0 :                         DPAA2_PMD_ERR(
    3267                 :            :                                 "Flow with group %d and priority %d already exists.",
    3268                 :            :                                 attr->group, attr->priority);
    3269                 :            : 
    3270                 :          0 :                         return -1;
    3271                 :            :                 }
    3272                 :          0 :                 curr = LIST_NEXT(curr, next);
    3273                 :            :         }
    3274                 :            : 
    3275                 :            :         return 0;
    3276                 :            : }
    3277                 :            : 
    3278                 :            : static inline struct rte_eth_dev *
    3279                 :          0 : dpaa2_flow_redirect_dev(struct dpaa2_dev_priv *priv,
    3280                 :            :         const struct rte_flow_action *action)
    3281                 :            : {
    3282                 :            :         const struct rte_flow_action_port_id *port_id;
    3283                 :            :         int idx = -1;
    3284                 :            :         struct rte_eth_dev *dest_dev;
    3285                 :            : 
    3286         [ #  # ]:          0 :         if (action->type == RTE_FLOW_ACTION_TYPE_PORT_ID) {
    3287                 :          0 :                 port_id = (const struct rte_flow_action_port_id *)
    3288                 :            :                                         action->conf;
    3289         [ #  # ]:          0 :                 if (!port_id->original)
    3290                 :          0 :                         idx = port_id->id;
    3291         [ #  # ]:          0 :         } else if (action->type == RTE_FLOW_ACTION_TYPE_REPRESENTED_PORT) {
    3292                 :            :                 const struct rte_flow_action_ethdev *ethdev;
    3293                 :            : 
    3294                 :          0 :                 ethdev = (const struct rte_flow_action_ethdev *)action->conf;
    3295                 :          0 :                 idx = ethdev->port_id;
    3296                 :            :         } else {
    3297                 :            :                 return NULL;
    3298                 :            :         }
    3299                 :            : 
    3300         [ #  # ]:          0 :         if (idx >= 0) {
    3301         [ #  # ]:          0 :                 if (!rte_eth_dev_is_valid_port(idx))
    3302                 :            :                         return NULL;
    3303                 :          0 :                 dest_dev = &rte_eth_devices[idx];
    3304                 :            :         } else {
    3305                 :          0 :                 dest_dev = priv->eth_dev;
    3306                 :            :         }
    3307                 :            : 
    3308         [ #  # ]:          0 :         if (!dpaa2_dev_is_dpaa2(dest_dev))
    3309                 :          0 :                 return NULL;
    3310                 :            : 
    3311                 :            :         return dest_dev;
    3312                 :            : }
    3313                 :            : 
    3314                 :            : static inline int
    3315                 :          0 : dpaa2_flow_verify_action(
    3316                 :            :         struct dpaa2_dev_priv *priv,
    3317                 :            :         const struct rte_flow_attr *attr,
    3318                 :            :         const struct rte_flow_action actions[])
    3319                 :            : {
    3320                 :            :         int end_of_list = 0, i, j = 0;
    3321                 :            :         const struct rte_flow_action_queue *dest_queue;
    3322                 :            :         const struct rte_flow_action_rss *rss_conf;
    3323                 :            :         struct dpaa2_queue *rxq;
    3324                 :            : 
    3325         [ #  # ]:          0 :         while (!end_of_list) {
    3326   [ #  #  #  #  :          0 :                 switch (actions[j].type) {
                      # ]
    3327                 :          0 :                 case RTE_FLOW_ACTION_TYPE_QUEUE:
    3328                 :          0 :                         dest_queue = (const struct rte_flow_action_queue *)
    3329                 :            :                                         (actions[j].conf);
    3330                 :          0 :                         rxq = priv->rx_vq[dest_queue->index];
    3331         [ #  # ]:          0 :                         if (attr->group != rxq->tc_index) {
    3332                 :          0 :                                 DPAA2_PMD_ERR(
    3333                 :            :                                         "RXQ[%d] does not belong to the group %d",
    3334                 :            :                                         dest_queue->index, attr->group);
    3335                 :            : 
    3336                 :          0 :                                 return -1;
    3337                 :            :                         }
    3338                 :            :                         break;
    3339                 :          0 :                 case RTE_FLOW_ACTION_TYPE_REPRESENTED_PORT:
    3340                 :            :                 case RTE_FLOW_ACTION_TYPE_PORT_ID:
    3341         [ #  # ]:          0 :                         if (!dpaa2_flow_redirect_dev(priv, &actions[j])) {
    3342                 :          0 :                                 DPAA2_PMD_ERR("Invalid port id of action");
    3343                 :          0 :                                 return -ENOTSUP;
    3344                 :            :                         }
    3345                 :            :                         break;
    3346                 :          0 :                 case RTE_FLOW_ACTION_TYPE_RSS:
    3347                 :          0 :                         rss_conf = (const struct rte_flow_action_rss *)
    3348                 :            :                                         (actions[j].conf);
    3349         [ #  # ]:          0 :                         if (rss_conf->queue_num > priv->dist_queues) {
    3350                 :          0 :                                 DPAA2_PMD_ERR(
    3351                 :            :                                         "RSS number exceeds the distribution size");
    3352                 :          0 :                                 return -ENOTSUP;
    3353                 :            :                         }
    3354         [ #  # ]:          0 :                         for (i = 0; i < (int)rss_conf->queue_num; i++) {
    3355         [ #  # ]:          0 :                                 if (rss_conf->queue[i] >= priv->nb_rx_queues) {
    3356                 :          0 :                                         DPAA2_PMD_ERR(
    3357                 :            :                                                 "RSS queue index exceeds the number of RXQs");
    3358                 :          0 :                                         return -ENOTSUP;
    3359                 :            :                                 }
    3360                 :          0 :                                 rxq = priv->rx_vq[rss_conf->queue[i]];
    3361         [ #  # ]:          0 :                                 if (rxq->tc_index != attr->group) {
    3362                 :          0 :                                         DPAA2_PMD_ERR(
    3363                 :            :                                                 "Queue/Group combination are not supported\n");
    3364                 :          0 :                                         return -ENOTSUP;
    3365                 :            :                                 }
    3366                 :            :                         }
    3367                 :            : 
    3368                 :            :                         break;
    3369                 :            :                 case RTE_FLOW_ACTION_TYPE_END:
    3370                 :            :                         end_of_list = 1;
    3371                 :            :                         break;
    3372                 :          0 :                 default:
    3373                 :          0 :                         DPAA2_PMD_ERR("Invalid action type");
    3374                 :          0 :                         return -ENOTSUP;
    3375                 :            :                 }
    3376                 :          0 :                 j++;
    3377                 :            :         }
    3378                 :            : 
    3379                 :            :         return 0;
    3380                 :            : }
    3381                 :            : 
    3382                 :            : static int
    3383                 :          0 : dpaa2_generic_flow_set(struct rte_flow *flow,
    3384                 :            :                        struct rte_eth_dev *dev,
    3385                 :            :                        const struct rte_flow_attr *attr,
    3386                 :            :                        const struct rte_flow_item pattern[],
    3387                 :            :                        const struct rte_flow_action actions[],
    3388                 :            :                        struct rte_flow_error *error)
    3389                 :            : {
    3390                 :            :         const struct rte_flow_action_queue *dest_queue;
    3391                 :            :         const struct rte_flow_action_rss *rss_conf;
    3392                 :          0 :         int is_keycfg_configured = 0, end_of_list = 0;
    3393                 :            :         int ret = 0, i = 0, j = 0;
    3394                 :            :         struct dpni_rx_dist_cfg tc_cfg;
    3395                 :            :         struct dpni_qos_tbl_cfg qos_cfg;
    3396                 :            :         struct dpni_fs_action_cfg action;
    3397                 :          0 :         struct dpaa2_dev_priv *priv = dev->data->dev_private;
    3398                 :            :         struct dpaa2_queue *dest_q;
    3399                 :          0 :         struct fsl_mc_io *dpni = (struct fsl_mc_io *)priv->hw;
    3400                 :            :         size_t param;
    3401                 :          0 :         struct rte_flow *curr = LIST_FIRST(&priv->flows);
    3402                 :            :         uint16_t qos_index;
    3403                 :            :         struct rte_eth_dev *dest_dev;
    3404                 :            :         struct dpaa2_dev_priv *dest_priv;
    3405                 :            : 
    3406                 :          0 :         ret = dpaa2_flow_verify_attr(priv, attr);
    3407         [ #  # ]:          0 :         if (ret)
    3408                 :            :                 return ret;
    3409                 :            : 
    3410                 :          0 :         ret = dpaa2_flow_verify_action(priv, attr, actions);
    3411         [ #  # ]:          0 :         if (ret)
    3412                 :            :                 return ret;
    3413                 :            : 
    3414                 :            :         /* Parse pattern list to get the matching parameters */
    3415         [ #  # ]:          0 :         while (!end_of_list) {
    3416   [ #  #  #  #  :          0 :                 switch (pattern[i].type) {
          #  #  #  #  #  
                   #  # ]
    3417                 :          0 :                 case RTE_FLOW_ITEM_TYPE_ETH:
    3418                 :          0 :                         ret = dpaa2_configure_flow_eth(flow,
    3419                 :            :                                         dev, attr, &pattern[i], actions, error,
    3420                 :            :                                         &is_keycfg_configured);
    3421         [ #  # ]:          0 :                         if (ret) {
    3422                 :          0 :                                 DPAA2_PMD_ERR("ETH flow configuration failed!");
    3423                 :          0 :                                 return ret;
    3424                 :            :                         }
    3425                 :            :                         break;
    3426                 :          0 :                 case RTE_FLOW_ITEM_TYPE_VLAN:
    3427                 :          0 :                         ret = dpaa2_configure_flow_vlan(flow,
    3428                 :            :                                         dev, attr, &pattern[i], actions, error,
    3429                 :            :                                         &is_keycfg_configured);
    3430         [ #  # ]:          0 :                         if (ret) {
    3431                 :          0 :                                 DPAA2_PMD_ERR("vLan flow configuration failed!");
    3432                 :          0 :                                 return ret;
    3433                 :            :                         }
    3434                 :            :                         break;
    3435                 :          0 :                 case RTE_FLOW_ITEM_TYPE_IPV4:
    3436                 :            :                 case RTE_FLOW_ITEM_TYPE_IPV6:
    3437                 :          0 :                         ret = dpaa2_configure_flow_generic_ip(flow,
    3438                 :            :                                         dev, attr, &pattern[i], actions, error,
    3439                 :            :                                         &is_keycfg_configured);
    3440         [ #  # ]:          0 :                         if (ret) {
    3441                 :          0 :                                 DPAA2_PMD_ERR("IP flow configuration failed!");
    3442                 :          0 :                                 return ret;
    3443                 :            :                         }
    3444                 :            :                         break;
    3445                 :          0 :                 case RTE_FLOW_ITEM_TYPE_ICMP:
    3446                 :          0 :                         ret = dpaa2_configure_flow_icmp(flow,
    3447                 :            :                                         dev, attr, &pattern[i], actions, error,
    3448                 :            :                                         &is_keycfg_configured);
    3449         [ #  # ]:          0 :                         if (ret) {
    3450                 :          0 :                                 DPAA2_PMD_ERR("ICMP flow configuration failed!");
    3451                 :          0 :                                 return ret;
    3452                 :            :                         }
    3453                 :            :                         break;
    3454                 :          0 :                 case RTE_FLOW_ITEM_TYPE_UDP:
    3455                 :          0 :                         ret = dpaa2_configure_flow_udp(flow,
    3456                 :            :                                         dev, attr, &pattern[i], actions, error,
    3457                 :            :                                         &is_keycfg_configured);
    3458         [ #  # ]:          0 :                         if (ret) {
    3459                 :          0 :                                 DPAA2_PMD_ERR("UDP flow configuration failed!");
    3460                 :          0 :                                 return ret;
    3461                 :            :                         }
    3462                 :            :                         break;
    3463                 :          0 :                 case RTE_FLOW_ITEM_TYPE_TCP:
    3464                 :          0 :                         ret = dpaa2_configure_flow_tcp(flow,
    3465                 :            :                                         dev, attr, &pattern[i], actions, error,
    3466                 :            :                                         &is_keycfg_configured);
    3467         [ #  # ]:          0 :                         if (ret) {
    3468                 :          0 :                                 DPAA2_PMD_ERR("TCP flow configuration failed!");
    3469                 :          0 :                                 return ret;
    3470                 :            :                         }
    3471                 :            :                         break;
    3472                 :          0 :                 case RTE_FLOW_ITEM_TYPE_SCTP:
    3473                 :          0 :                         ret = dpaa2_configure_flow_sctp(flow,
    3474                 :            :                                         dev, attr, &pattern[i], actions, error,
    3475                 :            :                                         &is_keycfg_configured);
    3476         [ #  # ]:          0 :                         if (ret) {
    3477                 :          0 :                                 DPAA2_PMD_ERR("SCTP flow configuration failed!");
    3478                 :          0 :                                 return ret;
    3479                 :            :                         }
    3480                 :            :                         break;
    3481                 :          0 :                 case RTE_FLOW_ITEM_TYPE_GRE:
    3482                 :          0 :                         ret = dpaa2_configure_flow_gre(flow,
    3483                 :            :                                         dev, attr, &pattern[i], actions, error,
    3484                 :            :                                         &is_keycfg_configured);
    3485         [ #  # ]:          0 :                         if (ret) {
    3486                 :          0 :                                 DPAA2_PMD_ERR("GRE flow configuration failed!");
    3487                 :          0 :                                 return ret;
    3488                 :            :                         }
    3489                 :            :                         break;
    3490                 :          0 :                 case RTE_FLOW_ITEM_TYPE_RAW:
    3491                 :          0 :                         ret = dpaa2_configure_flow_raw(flow,
    3492                 :            :                                                        dev, attr, &pattern[i],
    3493                 :            :                                                        actions, error,
    3494                 :            :                                                        &is_keycfg_configured);
    3495         [ #  # ]:          0 :                         if (ret) {
    3496                 :          0 :                                 DPAA2_PMD_ERR("RAW flow configuration failed!");
    3497                 :          0 :                                 return ret;
    3498                 :            :                         }
    3499                 :            :                         break;
    3500                 :            :                 case RTE_FLOW_ITEM_TYPE_END:
    3501                 :            :                         end_of_list = 1;
    3502                 :            :                         break; /*End of List*/
    3503                 :          0 :                 default:
    3504                 :          0 :                         DPAA2_PMD_ERR("Invalid action type");
    3505                 :            :                         ret = -ENOTSUP;
    3506                 :          0 :                         break;
    3507                 :            :                 }
    3508                 :          0 :                 i++;
    3509                 :            :         }
    3510                 :            : 
    3511                 :            :         /* Let's parse action on matching traffic */
    3512                 :            :         end_of_list = 0;
    3513         [ #  # ]:          0 :         while (!end_of_list) {
    3514   [ #  #  #  # ]:          0 :                 switch (actions[j].type) {
    3515                 :            :                 case RTE_FLOW_ACTION_TYPE_QUEUE:
    3516                 :            :                 case RTE_FLOW_ACTION_TYPE_REPRESENTED_PORT:
    3517                 :            :                 case RTE_FLOW_ACTION_TYPE_PORT_ID:
    3518                 :            :                         memset(&action, 0, sizeof(struct dpni_fs_action_cfg));
    3519                 :          0 :                         flow->action = actions[j].type;
    3520                 :            : 
    3521         [ #  # ]:          0 :                         if (actions[j].type == RTE_FLOW_ACTION_TYPE_QUEUE) {
    3522                 :          0 :                                 dest_queue = (const struct rte_flow_action_queue *)
    3523                 :            :                                                                 (actions[j].conf);
    3524                 :          0 :                                 dest_q = priv->rx_vq[dest_queue->index];
    3525                 :          0 :                                 action.flow_id = dest_q->flow_id;
    3526                 :            :                         } else {
    3527                 :          0 :                                 dest_dev = dpaa2_flow_redirect_dev(priv,
    3528                 :            :                                                                    &actions[j]);
    3529         [ #  # ]:          0 :                                 if (!dest_dev) {
    3530                 :          0 :                                         DPAA2_PMD_ERR("Invalid destination device to redirect!");
    3531                 :          0 :                                         return -1;
    3532                 :            :                                 }
    3533                 :            : 
    3534                 :          0 :                                 dest_priv = dest_dev->data->dev_private;
    3535                 :          0 :                                 dest_q = dest_priv->tx_vq[0];
    3536                 :          0 :                                 action.options =
    3537                 :            :                                                 DPNI_FS_OPT_REDIRECT_TO_DPNI_TX;
    3538                 :          0 :                                 action.redirect_obj_token = dest_priv->token;
    3539                 :          0 :                                 action.flow_id = dest_q->flow_id;
    3540                 :            :                         }
    3541                 :            : 
    3542                 :            :                         /* Configure FS table first*/
    3543         [ #  # ]:          0 :                         if (is_keycfg_configured & DPAA2_FS_TABLE_RECONFIGURE) {
    3544                 :          0 :                                 dpaa2_flow_fs_table_extracts_log(priv, flow->tc_id);
    3545         [ #  # ]:          0 :                                 if (dpkg_prepare_key_cfg(
    3546                 :          0 :                                 &priv->extract.tc_key_extract[flow->tc_id].dpkg,
    3547                 :            :                                 (uint8_t *)(size_t)priv->extract
    3548                 :          0 :                                 .tc_extract_param[flow->tc_id]) < 0) {
    3549                 :          0 :                                         DPAA2_PMD_ERR(
    3550                 :            :                                         "Unable to prepare extract parameters");
    3551                 :          0 :                                         return -1;
    3552                 :            :                                 }
    3553                 :            : 
    3554                 :            :                                 memset(&tc_cfg, 0,
    3555                 :            :                                         sizeof(struct dpni_rx_dist_cfg));
    3556                 :          0 :                                 tc_cfg.dist_size = priv->nb_rx_queues / priv->num_rx_tc;
    3557                 :          0 :                                 tc_cfg.key_cfg_iova =
    3558                 :          0 :                                         (uint64_t)priv->extract.tc_extract_param[flow->tc_id];
    3559                 :          0 :                                 tc_cfg.tc = flow->tc_id;
    3560                 :            :                                 tc_cfg.enable = false;
    3561                 :          0 :                                 ret = dpni_set_rx_hash_dist(dpni, CMD_PRI_LOW,
    3562                 :          0 :                                                 priv->token, &tc_cfg);
    3563         [ #  # ]:          0 :                                 if (ret < 0) {
    3564                 :          0 :                                         DPAA2_PMD_ERR(
    3565                 :            :                                                 "TC hash cannot be disabled.(%d)",
    3566                 :            :                                                 ret);
    3567                 :          0 :                                         return -1;
    3568                 :            :                                 }
    3569                 :          0 :                                 tc_cfg.enable = true;
    3570                 :          0 :                                 tc_cfg.fs_miss_flow_id = dpaa2_flow_miss_flow_id;
    3571                 :          0 :                                 ret = dpni_set_rx_fs_dist(dpni, CMD_PRI_LOW,
    3572                 :          0 :                                                          priv->token, &tc_cfg);
    3573         [ #  # ]:          0 :                                 if (ret < 0) {
    3574                 :          0 :                                         DPAA2_PMD_ERR(
    3575                 :            :                                                 "TC distribution cannot be configured.(%d)",
    3576                 :            :                                                 ret);
    3577                 :          0 :                                         return -1;
    3578                 :            :                                 }
    3579                 :            :                         }
    3580                 :            : 
    3581                 :            :                         /* Configure QoS table then.*/
    3582         [ #  # ]:          0 :                         if (is_keycfg_configured & DPAA2_QOS_TABLE_RECONFIGURE) {
    3583                 :          0 :                                 dpaa2_flow_qos_table_extracts_log(priv);
    3584         [ #  # ]:          0 :                                 if (dpkg_prepare_key_cfg(
    3585                 :          0 :                                         &priv->extract.qos_key_extract.dpkg,
    3586                 :          0 :                                         (uint8_t *)(size_t)priv->extract.qos_extract_param) < 0) {
    3587                 :          0 :                                         DPAA2_PMD_ERR(
    3588                 :            :                                                 "Unable to prepare extract parameters");
    3589                 :          0 :                                         return -1;
    3590                 :            :                                 }
    3591                 :            : 
    3592                 :            :                                 memset(&qos_cfg, 0, sizeof(struct dpni_qos_tbl_cfg));
    3593                 :            :                                 qos_cfg.discard_on_miss = false;
    3594                 :            :                                 qos_cfg.default_tc = 0;
    3595                 :          0 :                                 qos_cfg.keep_entries = true;
    3596                 :          0 :                                 qos_cfg.key_cfg_iova =
    3597                 :          0 :                                         (size_t)priv->extract.qos_extract_param;
    3598                 :            :                                 /* QoS table is effective for multiple TCs. */
    3599         [ #  # ]:          0 :                                 if (priv->num_rx_tc > 1) {
    3600                 :          0 :                                         ret = dpni_set_qos_table(dpni, CMD_PRI_LOW,
    3601                 :          0 :                                                 priv->token, &qos_cfg);
    3602         [ #  # ]:          0 :                                         if (ret < 0) {
    3603                 :          0 :                                                 DPAA2_PMD_ERR(
    3604                 :            :                                                 "RSS QoS table can not be configured(%d)\n",
    3605                 :            :                                                         ret);
    3606                 :          0 :                                                 return -1;
    3607                 :            :                                         }
    3608                 :            :                                 }
    3609                 :            :                         }
    3610                 :            : 
    3611                 :          0 :                         flow->qos_real_key_size = priv->extract
    3612                 :          0 :                                 .qos_key_extract.key_info.key_total_size;
    3613         [ #  # ]:          0 :                         if (flow->ipaddr_rule.ipaddr_type == FLOW_IPV4_ADDR) {
    3614                 :          0 :                                 if (flow->ipaddr_rule.qos_ipdst_offset >=
    3615         [ #  # ]:          0 :                                         flow->ipaddr_rule.qos_ipsrc_offset) {
    3616                 :          0 :                                         flow->qos_real_key_size =
    3617                 :          0 :                                                 flow->ipaddr_rule.qos_ipdst_offset +
    3618                 :            :                                                 NH_FLD_IPV4_ADDR_SIZE;
    3619                 :            :                                 } else {
    3620                 :          0 :                                         flow->qos_real_key_size =
    3621                 :          0 :                                                 flow->ipaddr_rule.qos_ipsrc_offset +
    3622                 :            :                                                 NH_FLD_IPV4_ADDR_SIZE;
    3623                 :            :                                 }
    3624         [ #  # ]:          0 :                         } else if (flow->ipaddr_rule.ipaddr_type ==
    3625                 :            :                                 FLOW_IPV6_ADDR) {
    3626                 :          0 :                                 if (flow->ipaddr_rule.qos_ipdst_offset >=
    3627         [ #  # ]:          0 :                                         flow->ipaddr_rule.qos_ipsrc_offset) {
    3628                 :          0 :                                         flow->qos_real_key_size =
    3629                 :          0 :                                                 flow->ipaddr_rule.qos_ipdst_offset +
    3630                 :            :                                                 NH_FLD_IPV6_ADDR_SIZE;
    3631                 :            :                                 } else {
    3632                 :          0 :                                         flow->qos_real_key_size =
    3633                 :          0 :                                                 flow->ipaddr_rule.qos_ipsrc_offset +
    3634                 :            :                                                 NH_FLD_IPV6_ADDR_SIZE;
    3635                 :            :                                 }
    3636                 :            :                         }
    3637                 :            : 
    3638                 :            :                         /* QoS entry added is only effective for multiple TCs.*/
    3639         [ #  # ]:          0 :                         if (priv->num_rx_tc > 1) {
    3640                 :          0 :                                 qos_index = flow->tc_id * priv->fs_entries +
    3641                 :          0 :                                         flow->tc_index;
    3642         [ #  # ]:          0 :                                 if (qos_index >= priv->qos_entries) {
    3643                 :          0 :                                         DPAA2_PMD_ERR("QoS table with %d entries full",
    3644                 :            :                                                 priv->qos_entries);
    3645                 :          0 :                                         return -1;
    3646                 :            :                                 }
    3647                 :          0 :                                 flow->qos_rule.key_size = FIXED_ENTRY_SIZE;
    3648                 :            : 
    3649                 :          0 :                                 dpaa2_flow_qos_entry_log("Start add", flow, qos_index);
    3650                 :            : 
    3651                 :          0 :                                 ret = dpni_add_qos_entry(dpni, CMD_PRI_LOW,
    3652                 :          0 :                                                 priv->token, &flow->qos_rule,
    3653                 :          0 :                                                 flow->tc_id, qos_index,
    3654                 :            :                                                 0, 0);
    3655         [ #  # ]:          0 :                                 if (ret < 0) {
    3656                 :          0 :                                         DPAA2_PMD_ERR(
    3657                 :            :                                                 "Error in adding entry to QoS table(%d)", ret);
    3658                 :          0 :                                         return ret;
    3659                 :            :                                 }
    3660                 :            :                         }
    3661                 :            : 
    3662         [ #  # ]:          0 :                         if (flow->tc_index >= priv->fs_entries) {
    3663                 :          0 :                                 DPAA2_PMD_ERR("FS table with %d entries full",
    3664                 :            :                                         priv->fs_entries);
    3665                 :          0 :                                 return -1;
    3666                 :            :                         }
    3667                 :            : 
    3668                 :          0 :                         flow->fs_real_key_size =
    3669                 :          0 :                                 priv->extract.tc_key_extract[flow->tc_id]
    3670                 :          0 :                                 .key_info.key_total_size;
    3671                 :            : 
    3672         [ #  # ]:          0 :                         if (flow->ipaddr_rule.ipaddr_type ==
    3673                 :            :                                 FLOW_IPV4_ADDR) {
    3674                 :          0 :                                 if (flow->ipaddr_rule.fs_ipdst_offset >=
    3675         [ #  # ]:          0 :                                         flow->ipaddr_rule.fs_ipsrc_offset) {
    3676                 :          0 :                                         flow->fs_real_key_size =
    3677                 :          0 :                                                 flow->ipaddr_rule.fs_ipdst_offset +
    3678                 :            :                                                 NH_FLD_IPV4_ADDR_SIZE;
    3679                 :            :                                 } else {
    3680                 :          0 :                                         flow->fs_real_key_size =
    3681                 :          0 :                                                 flow->ipaddr_rule.fs_ipsrc_offset +
    3682                 :            :                                                 NH_FLD_IPV4_ADDR_SIZE;
    3683                 :            :                                 }
    3684         [ #  # ]:          0 :                         } else if (flow->ipaddr_rule.ipaddr_type ==
    3685                 :            :                                 FLOW_IPV6_ADDR) {
    3686                 :          0 :                                 if (flow->ipaddr_rule.fs_ipdst_offset >=
    3687         [ #  # ]:          0 :                                         flow->ipaddr_rule.fs_ipsrc_offset) {
    3688                 :          0 :                                         flow->fs_real_key_size =
    3689                 :          0 :                                                 flow->ipaddr_rule.fs_ipdst_offset +
    3690                 :            :                                                 NH_FLD_IPV6_ADDR_SIZE;
    3691                 :            :                                 } else {
    3692                 :          0 :                                         flow->fs_real_key_size =
    3693                 :          0 :                                                 flow->ipaddr_rule.fs_ipsrc_offset +
    3694                 :            :                                                 NH_FLD_IPV6_ADDR_SIZE;
    3695                 :            :                                 }
    3696                 :            :                         }
    3697                 :            : 
    3698                 :          0 :                         flow->fs_rule.key_size = FIXED_ENTRY_SIZE;
    3699                 :            : 
    3700                 :          0 :                         dpaa2_flow_fs_entry_log("Start add", flow);
    3701                 :            : 
    3702                 :          0 :                         ret = dpni_add_fs_entry(dpni, CMD_PRI_LOW, priv->token,
    3703                 :          0 :                                                 flow->tc_id, flow->tc_index,
    3704                 :          0 :                                                 &flow->fs_rule, &action);
    3705         [ #  # ]:          0 :                         if (ret < 0) {
    3706                 :          0 :                                 DPAA2_PMD_ERR(
    3707                 :            :                                 "Error in adding entry to FS table(%d)", ret);
    3708                 :          0 :                                 return ret;
    3709                 :            :                         }
    3710                 :          0 :                         memcpy(&flow->action_cfg, &action,
    3711                 :            :                                 sizeof(struct dpni_fs_action_cfg));
    3712                 :            :                         break;
    3713                 :          0 :                 case RTE_FLOW_ACTION_TYPE_RSS:
    3714                 :          0 :                         rss_conf = (const struct rte_flow_action_rss *)(actions[j].conf);
    3715                 :            : 
    3716                 :          0 :                         flow->action = RTE_FLOW_ACTION_TYPE_RSS;
    3717                 :          0 :                         ret = dpaa2_distset_to_dpkg_profile_cfg(rss_conf->types,
    3718                 :          0 :                                         &priv->extract.tc_key_extract[flow->tc_id].dpkg);
    3719         [ #  # ]:          0 :                         if (ret < 0) {
    3720                 :          0 :                                 DPAA2_PMD_ERR(
    3721                 :            :                                 "unable to set flow distribution.please check queue config\n");
    3722                 :          0 :                                 return ret;
    3723                 :            :                         }
    3724                 :            : 
    3725                 :            :                         /* Allocate DMA'ble memory to write the rules */
    3726                 :          0 :                         param = (size_t)rte_malloc(NULL, 256, 64);
    3727         [ #  # ]:          0 :                         if (!param) {
    3728                 :          0 :                                 DPAA2_PMD_ERR("Memory allocation failure\n");
    3729                 :          0 :                                 return -1;
    3730                 :            :                         }
    3731                 :            : 
    3732         [ #  # ]:          0 :                         if (dpkg_prepare_key_cfg(
    3733                 :          0 :                                 &priv->extract.tc_key_extract[flow->tc_id].dpkg,
    3734                 :            :                                 (uint8_t *)param) < 0) {
    3735                 :          0 :                                 DPAA2_PMD_ERR(
    3736                 :            :                                 "Unable to prepare extract parameters");
    3737                 :          0 :                                 rte_free((void *)param);
    3738                 :          0 :                                 return -1;
    3739                 :            :                         }
    3740                 :            : 
    3741                 :            :                         memset(&tc_cfg, 0, sizeof(struct dpni_rx_dist_cfg));
    3742                 :          0 :                         tc_cfg.dist_size = rss_conf->queue_num;
    3743                 :          0 :                         tc_cfg.key_cfg_iova = (size_t)param;
    3744                 :          0 :                         tc_cfg.enable = true;
    3745                 :          0 :                         tc_cfg.tc = flow->tc_id;
    3746                 :          0 :                         ret = dpni_set_rx_hash_dist(dpni, CMD_PRI_LOW,
    3747                 :          0 :                                                  priv->token, &tc_cfg);
    3748         [ #  # ]:          0 :                         if (ret < 0) {
    3749                 :          0 :                                 DPAA2_PMD_ERR(
    3750                 :            :                                         "RSS TC table cannot be configured: %d\n",
    3751                 :            :                                         ret);
    3752                 :          0 :                                 rte_free((void *)param);
    3753                 :          0 :                                 return -1;
    3754                 :            :                         }
    3755                 :            : 
    3756                 :          0 :                         rte_free((void *)param);
    3757         [ #  # ]:          0 :                         if (is_keycfg_configured & DPAA2_QOS_TABLE_RECONFIGURE) {
    3758         [ #  # ]:          0 :                                 if (dpkg_prepare_key_cfg(
    3759                 :          0 :                                         &priv->extract.qos_key_extract.dpkg,
    3760                 :          0 :                                         (uint8_t *)(size_t)priv->extract.qos_extract_param) < 0) {
    3761                 :          0 :                                         DPAA2_PMD_ERR(
    3762                 :            :                                         "Unable to prepare extract parameters");
    3763                 :          0 :                                         return -1;
    3764                 :            :                                 }
    3765                 :            :                                 memset(&qos_cfg, 0,
    3766                 :            :                                         sizeof(struct dpni_qos_tbl_cfg));
    3767                 :          0 :                                 qos_cfg.discard_on_miss = true;
    3768                 :          0 :                                 qos_cfg.keep_entries = true;
    3769                 :          0 :                                 qos_cfg.key_cfg_iova =
    3770                 :          0 :                                         (size_t)priv->extract.qos_extract_param;
    3771                 :          0 :                                 ret = dpni_set_qos_table(dpni, CMD_PRI_LOW,
    3772                 :          0 :                                                          priv->token, &qos_cfg);
    3773         [ #  # ]:          0 :                                 if (ret < 0) {
    3774                 :          0 :                                         DPAA2_PMD_ERR(
    3775                 :            :                                         "RSS QoS dist can't be configured-%d\n",
    3776                 :            :                                         ret);
    3777                 :          0 :                                         return -1;
    3778                 :            :                                 }
    3779                 :            :                         }
    3780                 :            : 
    3781                 :            :                         /* Add Rule into QoS table */
    3782                 :          0 :                         qos_index = flow->tc_id * priv->fs_entries +
    3783                 :          0 :                                 flow->tc_index;
    3784         [ #  # ]:          0 :                         if (qos_index >= priv->qos_entries) {
    3785                 :          0 :                                 DPAA2_PMD_ERR("QoS table with %d entries full",
    3786                 :            :                                         priv->qos_entries);
    3787                 :          0 :                                 return -1;
    3788                 :            :                         }
    3789                 :            : 
    3790                 :          0 :                         flow->qos_real_key_size =
    3791                 :          0 :                           priv->extract.qos_key_extract.key_info.key_total_size;
    3792                 :          0 :                         flow->qos_rule.key_size = FIXED_ENTRY_SIZE;
    3793                 :          0 :                         ret = dpni_add_qos_entry(dpni, CMD_PRI_LOW, priv->token,
    3794                 :          0 :                                                 &flow->qos_rule, flow->tc_id,
    3795                 :            :                                                 qos_index, 0, 0);
    3796         [ #  # ]:          0 :                         if (ret < 0) {
    3797                 :          0 :                                 DPAA2_PMD_ERR(
    3798                 :            :                                 "Error in entry addition in QoS table(%d)",
    3799                 :            :                                 ret);
    3800                 :          0 :                                 return ret;
    3801                 :            :                         }
    3802                 :            :                         break;
    3803                 :            :                 case RTE_FLOW_ACTION_TYPE_END:
    3804                 :            :                         end_of_list = 1;
    3805                 :            :                         break;
    3806                 :          0 :                 default:
    3807                 :          0 :                         DPAA2_PMD_ERR("Invalid action type");
    3808                 :            :                         ret = -ENOTSUP;
    3809                 :          0 :                         break;
    3810                 :            :                 }
    3811                 :          0 :                 j++;
    3812                 :            :         }
    3813                 :            : 
    3814         [ #  # ]:          0 :         if (!ret) {
    3815         [ #  # ]:          0 :                 if (is_keycfg_configured &
    3816                 :            :                         (DPAA2_QOS_TABLE_RECONFIGURE |
    3817                 :            :                         DPAA2_FS_TABLE_RECONFIGURE)) {
    3818                 :          0 :                         ret = dpaa2_flow_entry_update(priv, flow->tc_id);
    3819         [ #  # ]:          0 :                         if (ret) {
    3820                 :          0 :                                 DPAA2_PMD_ERR("Flow entry update failed.");
    3821                 :            : 
    3822                 :          0 :                                 return -1;
    3823                 :            :                         }
    3824                 :            :                 }
    3825                 :            :                 /* New rules are inserted. */
    3826         [ #  # ]:          0 :                 if (!curr) {
    3827         [ #  # ]:          0 :                         LIST_INSERT_HEAD(&priv->flows, flow, next);
    3828                 :            :                 } else {
    3829         [ #  # ]:          0 :                         while (LIST_NEXT(curr, next))
    3830                 :            :                                 curr = LIST_NEXT(curr, next);
    3831                 :          0 :                         LIST_INSERT_AFTER(curr, flow, next);
    3832                 :            :                 }
    3833                 :            :         }
    3834                 :            :         return ret;
    3835                 :            : }
    3836                 :            : 
    3837                 :            : static inline int
    3838                 :          0 : dpaa2_dev_verify_attr(struct dpni_attr *dpni_attr,
    3839                 :            :                       const struct rte_flow_attr *attr)
    3840                 :            : {
    3841                 :            :         int ret = 0;
    3842                 :            : 
    3843         [ #  # ]:          0 :         if (unlikely(attr->group >= dpni_attr->num_rx_tcs)) {
    3844                 :          0 :                 DPAA2_PMD_ERR("Priority group is out of range\n");
    3845                 :            :                 ret = -ENOTSUP;
    3846                 :            :         }
    3847         [ #  # ]:          0 :         if (unlikely(attr->priority >= dpni_attr->fs_entries)) {
    3848                 :          0 :                 DPAA2_PMD_ERR("Priority within the group is out of range\n");
    3849                 :            :                 ret = -ENOTSUP;
    3850                 :            :         }
    3851         [ #  # ]:          0 :         if (unlikely(attr->egress)) {
    3852                 :          0 :                 DPAA2_PMD_ERR(
    3853                 :            :                         "Flow configuration is not supported on egress side\n");
    3854                 :            :                 ret = -ENOTSUP;
    3855                 :            :         }
    3856         [ #  # ]:          0 :         if (unlikely(!attr->ingress)) {
    3857                 :          0 :                 DPAA2_PMD_ERR("Ingress flag must be configured\n");
    3858                 :            :                 ret = -EINVAL;
    3859                 :            :         }
    3860                 :          0 :         return ret;
    3861                 :            : }
    3862                 :            : 
    3863                 :            : static inline int
    3864                 :          0 : dpaa2_dev_verify_patterns(const struct rte_flow_item pattern[])
    3865                 :            : {
    3866                 :            :         unsigned int i, j, is_found = 0;
    3867                 :            :         int ret = 0;
    3868                 :            : 
    3869         [ #  # ]:          0 :         for (j = 0; pattern[j].type != RTE_FLOW_ITEM_TYPE_END; j++) {
    3870         [ #  # ]:          0 :                 for (i = 0; i < RTE_DIM(dpaa2_supported_pattern_type); i++) {
    3871         [ #  # ]:          0 :                         if (dpaa2_supported_pattern_type[i]
    3872                 :            :                                         == pattern[j].type) {
    3873                 :            :                                 is_found = 1;
    3874                 :            :                                 break;
    3875                 :            :                         }
    3876                 :            :                 }
    3877         [ #  # ]:          0 :                 if (!is_found) {
    3878                 :            :                         ret = -ENOTSUP;
    3879                 :            :                         break;
    3880                 :            :                 }
    3881                 :            :         }
    3882                 :            :         /* Lets verify other combinations of given pattern rules */
    3883         [ #  # ]:          0 :         for (j = 0; pattern[j].type != RTE_FLOW_ITEM_TYPE_END; j++) {
    3884         [ #  # ]:          0 :                 if (!pattern[j].spec) {
    3885                 :            :                         ret = -EINVAL;
    3886                 :            :                         break;
    3887                 :            :                 }
    3888                 :            :         }
    3889                 :            : 
    3890                 :          0 :         return ret;
    3891                 :            : }
    3892                 :            : 
    3893                 :            : static inline int
    3894                 :          0 : dpaa2_dev_verify_actions(const struct rte_flow_action actions[])
    3895                 :            : {
    3896                 :            :         unsigned int i, j, is_found = 0;
    3897                 :            :         int ret = 0;
    3898                 :            : 
    3899         [ #  # ]:          0 :         for (j = 0; actions[j].type != RTE_FLOW_ACTION_TYPE_END; j++) {
    3900         [ #  # ]:          0 :                 for (i = 0; i < RTE_DIM(dpaa2_supported_action_type); i++) {
    3901         [ #  # ]:          0 :                         if (dpaa2_supported_action_type[i] == actions[j].type) {
    3902                 :            :                                 is_found = 1;
    3903                 :            :                                 break;
    3904                 :            :                         }
    3905                 :            :                 }
    3906         [ #  # ]:          0 :                 if (!is_found) {
    3907                 :            :                         ret = -ENOTSUP;
    3908                 :            :                         break;
    3909                 :            :                 }
    3910                 :            :         }
    3911         [ #  # ]:          0 :         for (j = 0; actions[j].type != RTE_FLOW_ACTION_TYPE_END; j++) {
    3912         [ #  # ]:          0 :                 if (actions[j].type != RTE_FLOW_ACTION_TYPE_DROP &&
    3913         [ #  # ]:          0 :                                 !actions[j].conf)
    3914                 :            :                         ret = -EINVAL;
    3915                 :            :         }
    3916                 :          0 :         return ret;
    3917                 :            : }
    3918                 :            : 
    3919                 :            : static
    3920                 :          0 : int dpaa2_flow_validate(struct rte_eth_dev *dev,
    3921                 :            :                         const struct rte_flow_attr *flow_attr,
    3922                 :            :                         const struct rte_flow_item pattern[],
    3923                 :            :                         const struct rte_flow_action actions[],
    3924                 :            :                         struct rte_flow_error *error)
    3925                 :            : {
    3926                 :          0 :         struct dpaa2_dev_priv *priv = dev->data->dev_private;
    3927                 :            :         struct dpni_attr dpni_attr;
    3928                 :          0 :         struct fsl_mc_io *dpni = (struct fsl_mc_io *)priv->hw;
    3929                 :          0 :         uint16_t token = priv->token;
    3930                 :            :         int ret = 0;
    3931                 :            : 
    3932                 :            :         memset(&dpni_attr, 0, sizeof(struct dpni_attr));
    3933                 :          0 :         ret = dpni_get_attributes(dpni, CMD_PRI_LOW, token, &dpni_attr);
    3934         [ #  # ]:          0 :         if (ret < 0) {
    3935                 :          0 :                 DPAA2_PMD_ERR(
    3936                 :            :                         "Failure to get dpni@%p attribute, err code  %d\n",
    3937                 :            :                         dpni, ret);
    3938                 :          0 :                 rte_flow_error_set(error, EPERM,
    3939                 :            :                            RTE_FLOW_ERROR_TYPE_ATTR,
    3940                 :            :                            flow_attr, "invalid");
    3941                 :          0 :                 return ret;
    3942                 :            :         }
    3943                 :            : 
    3944                 :            :         /* Verify input attributes */
    3945                 :          0 :         ret = dpaa2_dev_verify_attr(&dpni_attr, flow_attr);
    3946         [ #  # ]:          0 :         if (ret < 0) {
    3947                 :          0 :                 DPAA2_PMD_ERR(
    3948                 :            :                         "Invalid attributes are given\n");
    3949                 :          0 :                 rte_flow_error_set(error, EPERM,
    3950                 :            :                            RTE_FLOW_ERROR_TYPE_ATTR,
    3951                 :            :                            flow_attr, "invalid");
    3952                 :          0 :                 goto not_valid_params;
    3953                 :            :         }
    3954                 :            :         /* Verify input pattern list */
    3955                 :          0 :         ret = dpaa2_dev_verify_patterns(pattern);
    3956         [ #  # ]:          0 :         if (ret < 0) {
    3957                 :          0 :                 DPAA2_PMD_ERR(
    3958                 :            :                         "Invalid pattern list is given\n");
    3959                 :          0 :                 rte_flow_error_set(error, EPERM,
    3960                 :            :                            RTE_FLOW_ERROR_TYPE_ITEM,
    3961                 :            :                            pattern, "invalid");
    3962                 :          0 :                 goto not_valid_params;
    3963                 :            :         }
    3964                 :            :         /* Verify input action list */
    3965                 :          0 :         ret = dpaa2_dev_verify_actions(actions);
    3966         [ #  # ]:          0 :         if (ret < 0) {
    3967                 :          0 :                 DPAA2_PMD_ERR(
    3968                 :            :                         "Invalid action list is given\n");
    3969                 :          0 :                 rte_flow_error_set(error, EPERM,
    3970                 :            :                            RTE_FLOW_ERROR_TYPE_ACTION,
    3971                 :            :                            actions, "invalid");
    3972                 :          0 :                 goto not_valid_params;
    3973                 :            :         }
    3974                 :          0 : not_valid_params:
    3975                 :            :         return ret;
    3976                 :            : }
    3977                 :            : 
    3978                 :            : static
    3979                 :          0 : struct rte_flow *dpaa2_flow_create(struct rte_eth_dev *dev,
    3980                 :            :                                    const struct rte_flow_attr *attr,
    3981                 :            :                                    const struct rte_flow_item pattern[],
    3982                 :            :                                    const struct rte_flow_action actions[],
    3983                 :            :                                    struct rte_flow_error *error)
    3984                 :            : {
    3985                 :            :         struct rte_flow *flow = NULL;
    3986                 :            :         size_t key_iova = 0, mask_iova = 0;
    3987                 :            :         int ret;
    3988                 :            : 
    3989                 :          0 :         dpaa2_flow_control_log =
    3990                 :          0 :                 getenv("DPAA2_FLOW_CONTROL_LOG");
    3991                 :            : 
    3992         [ #  # ]:          0 :         if (getenv("DPAA2_FLOW_CONTROL_MISS_FLOW")) {
    3993                 :          0 :                 struct dpaa2_dev_priv *priv = dev->data->dev_private;
    3994                 :            : 
    3995                 :          0 :                 dpaa2_flow_miss_flow_id =
    3996                 :          0 :                         atoi(getenv("DPAA2_FLOW_CONTROL_MISS_FLOW"));
    3997         [ #  # ]:          0 :                 if (dpaa2_flow_miss_flow_id >= priv->dist_queues) {
    3998                 :          0 :                         DPAA2_PMD_ERR(
    3999                 :            :                                 "The missed flow ID %d exceeds the max flow ID %d",
    4000                 :            :                                 dpaa2_flow_miss_flow_id,
    4001                 :            :                                 priv->dist_queues - 1);
    4002                 :          0 :                         return NULL;
    4003                 :            :                 }
    4004                 :            :         }
    4005                 :            : 
    4006                 :          0 :         flow = rte_zmalloc(NULL, sizeof(struct rte_flow), RTE_CACHE_LINE_SIZE);
    4007         [ #  # ]:          0 :         if (!flow) {
    4008                 :          0 :                 DPAA2_PMD_ERR("Failure to allocate memory for flow");
    4009                 :          0 :                 goto mem_failure;
    4010                 :            :         }
    4011                 :            :         /* Allocate DMA'ble memory to write the rules */
    4012                 :          0 :         key_iova = (size_t)rte_zmalloc(NULL, 256, 64);
    4013         [ #  # ]:          0 :         if (!key_iova) {
    4014                 :          0 :                 DPAA2_PMD_ERR(
    4015                 :            :                         "Memory allocation failure for rule configuration\n");
    4016                 :          0 :                 goto mem_failure;
    4017                 :            :         }
    4018                 :          0 :         mask_iova = (size_t)rte_zmalloc(NULL, 256, 64);
    4019         [ #  # ]:          0 :         if (!mask_iova) {
    4020                 :          0 :                 DPAA2_PMD_ERR(
    4021                 :            :                         "Memory allocation failure for rule configuration\n");
    4022                 :          0 :                 goto mem_failure;
    4023                 :            :         }
    4024                 :            : 
    4025                 :          0 :         flow->qos_rule.key_iova = key_iova;
    4026                 :          0 :         flow->qos_rule.mask_iova = mask_iova;
    4027                 :            : 
    4028                 :            :         /* Allocate DMA'ble memory to write the rules */
    4029                 :          0 :         key_iova = (size_t)rte_zmalloc(NULL, 256, 64);
    4030         [ #  # ]:          0 :         if (!key_iova) {
    4031                 :          0 :                 DPAA2_PMD_ERR(
    4032                 :            :                         "Memory allocation failure for rule configuration\n");
    4033                 :          0 :                 goto mem_failure;
    4034                 :            :         }
    4035                 :          0 :         mask_iova = (size_t)rte_zmalloc(NULL, 256, 64);
    4036         [ #  # ]:          0 :         if (!mask_iova) {
    4037                 :          0 :                 DPAA2_PMD_ERR(
    4038                 :            :                         "Memory allocation failure for rule configuration\n");
    4039                 :          0 :                 goto mem_failure;
    4040                 :            :         }
    4041                 :            : 
    4042                 :          0 :         flow->fs_rule.key_iova = key_iova;
    4043                 :          0 :         flow->fs_rule.mask_iova = mask_iova;
    4044                 :            : 
    4045                 :          0 :         flow->ipaddr_rule.ipaddr_type = FLOW_NONE_IPADDR;
    4046                 :          0 :         flow->ipaddr_rule.qos_ipsrc_offset =
    4047                 :            :                 IP_ADDRESS_OFFSET_INVALID;
    4048                 :          0 :         flow->ipaddr_rule.qos_ipdst_offset =
    4049                 :            :                 IP_ADDRESS_OFFSET_INVALID;
    4050                 :          0 :         flow->ipaddr_rule.fs_ipsrc_offset =
    4051                 :            :                 IP_ADDRESS_OFFSET_INVALID;
    4052                 :          0 :         flow->ipaddr_rule.fs_ipdst_offset =
    4053                 :            :                 IP_ADDRESS_OFFSET_INVALID;
    4054                 :            : 
    4055                 :          0 :         ret = dpaa2_generic_flow_set(flow, dev, attr, pattern,
    4056                 :            :                         actions, error);
    4057         [ #  # ]:          0 :         if (ret < 0) {
    4058   [ #  #  #  # ]:          0 :                 if (error && error->type > RTE_FLOW_ERROR_TYPE_ACTION)
    4059                 :          0 :                         rte_flow_error_set(error, EPERM,
    4060                 :            :                                         RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
    4061                 :            :                                         attr, "unknown");
    4062                 :          0 :                 DPAA2_PMD_ERR("Failure to create flow, return code (%d)", ret);
    4063                 :          0 :                 goto creation_error;
    4064                 :            :         }
    4065                 :            : 
    4066                 :            :         return flow;
    4067                 :          0 : mem_failure:
    4068                 :          0 :         rte_flow_error_set(error, EPERM,
    4069                 :            :                            RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
    4070                 :            :                            NULL, "memory alloc");
    4071                 :          0 : creation_error:
    4072                 :          0 :         rte_free((void *)flow);
    4073                 :          0 :         rte_free((void *)key_iova);
    4074                 :          0 :         rte_free((void *)mask_iova);
    4075                 :            : 
    4076                 :          0 :         return NULL;
    4077                 :            : }
    4078                 :            : 
    4079                 :            : static
    4080                 :          0 : int dpaa2_flow_destroy(struct rte_eth_dev *dev,
    4081                 :            :                        struct rte_flow *flow,
    4082                 :            :                        struct rte_flow_error *error)
    4083                 :            : {
    4084                 :            :         int ret = 0;
    4085                 :          0 :         struct dpaa2_dev_priv *priv = dev->data->dev_private;
    4086                 :          0 :         struct fsl_mc_io *dpni = (struct fsl_mc_io *)priv->hw;
    4087                 :            : 
    4088      [ #  #  # ]:          0 :         switch (flow->action) {
    4089                 :          0 :         case RTE_FLOW_ACTION_TYPE_QUEUE:
    4090                 :            :         case RTE_FLOW_ACTION_TYPE_REPRESENTED_PORT:
    4091                 :            :         case RTE_FLOW_ACTION_TYPE_PORT_ID:
    4092         [ #  # ]:          0 :                 if (priv->num_rx_tc > 1) {
    4093                 :            :                         /* Remove entry from QoS table first */
    4094                 :          0 :                         ret = dpni_remove_qos_entry(dpni, CMD_PRI_LOW, priv->token,
    4095                 :          0 :                                         &flow->qos_rule);
    4096         [ #  # ]:          0 :                         if (ret < 0) {
    4097                 :          0 :                                 DPAA2_PMD_ERR(
    4098                 :            :                                         "Error in removing entry from QoS table(%d)", ret);
    4099                 :          0 :                                 goto error;
    4100                 :            :                         }
    4101                 :            :                 }
    4102                 :            : 
    4103                 :            :                 /* Then remove entry from FS table */
    4104                 :          0 :                 ret = dpni_remove_fs_entry(dpni, CMD_PRI_LOW, priv->token,
    4105                 :          0 :                                            flow->tc_id, &flow->fs_rule);
    4106         [ #  # ]:          0 :                 if (ret < 0) {
    4107                 :          0 :                         DPAA2_PMD_ERR(
    4108                 :            :                                 "Error in removing entry from FS table(%d)", ret);
    4109                 :          0 :                         goto error;
    4110                 :            :                 }
    4111                 :            :                 break;
    4112                 :          0 :         case RTE_FLOW_ACTION_TYPE_RSS:
    4113         [ #  # ]:          0 :                 if (priv->num_rx_tc > 1) {
    4114                 :          0 :                         ret = dpni_remove_qos_entry(dpni, CMD_PRI_LOW, priv->token,
    4115                 :          0 :                                         &flow->qos_rule);
    4116         [ #  # ]:          0 :                         if (ret < 0) {
    4117                 :          0 :                                 DPAA2_PMD_ERR(
    4118                 :            :                                         "Error in entry addition in QoS table(%d)", ret);
    4119                 :          0 :                                 goto error;
    4120                 :            :                         }
    4121                 :            :                 }
    4122                 :            :                 break;
    4123                 :          0 :         default:
    4124                 :          0 :                 DPAA2_PMD_ERR(
    4125                 :            :                 "Action type (%d) is not supported", flow->action);
    4126                 :            :                 ret = -ENOTSUP;
    4127                 :          0 :                 break;
    4128                 :            :         }
    4129                 :            : 
    4130         [ #  # ]:          0 :         LIST_REMOVE(flow, next);
    4131                 :          0 :         rte_free((void *)(size_t)flow->qos_rule.key_iova);
    4132                 :          0 :         rte_free((void *)(size_t)flow->qos_rule.mask_iova);
    4133                 :          0 :         rte_free((void *)(size_t)flow->fs_rule.key_iova);
    4134                 :          0 :         rte_free((void *)(size_t)flow->fs_rule.mask_iova);
    4135                 :            :         /* Now free the flow */
    4136                 :          0 :         rte_free(flow);
    4137                 :            : 
    4138                 :          0 : error:
    4139         [ #  # ]:          0 :         if (ret)
    4140                 :          0 :                 rte_flow_error_set(error, EPERM,
    4141                 :            :                                    RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
    4142                 :            :                                    NULL, "unknown");
    4143                 :          0 :         return ret;
    4144                 :            : }
    4145                 :            : 
    4146                 :            : /**
    4147                 :            :  * Destroy user-configured flow rules.
    4148                 :            :  *
    4149                 :            :  * This function skips internal flows rules.
    4150                 :            :  *
    4151                 :            :  * @see rte_flow_flush()
    4152                 :            :  * @see rte_flow_ops
    4153                 :            :  */
    4154                 :            : static int
    4155                 :          0 : dpaa2_flow_flush(struct rte_eth_dev *dev,
    4156                 :            :                 struct rte_flow_error *error)
    4157                 :            : {
    4158                 :          0 :         struct dpaa2_dev_priv *priv = dev->data->dev_private;
    4159                 :          0 :         struct rte_flow *flow = LIST_FIRST(&priv->flows);
    4160                 :            : 
    4161         [ #  # ]:          0 :         while (flow) {
    4162                 :          0 :                 struct rte_flow *next = LIST_NEXT(flow, next);
    4163                 :            : 
    4164                 :          0 :                 dpaa2_flow_destroy(dev, flow, error);
    4165                 :            :                 flow = next;
    4166                 :            :         }
    4167                 :          0 :         return 0;
    4168                 :            : }
    4169                 :            : 
    4170                 :            : static int
    4171                 :          0 : dpaa2_flow_query(struct rte_eth_dev *dev __rte_unused,
    4172                 :            :                 struct rte_flow *flow __rte_unused,
    4173                 :            :                 const struct rte_flow_action *actions __rte_unused,
    4174                 :            :                 void *data __rte_unused,
    4175                 :            :                 struct rte_flow_error *error __rte_unused)
    4176                 :            : {
    4177                 :          0 :         return 0;
    4178                 :            : }
    4179                 :            : 
    4180                 :            : /**
    4181                 :            :  * Clean up all flow rules.
    4182                 :            :  *
    4183                 :            :  * Unlike dpaa2_flow_flush(), this function takes care of all remaining flow
    4184                 :            :  * rules regardless of whether they are internal or user-configured.
    4185                 :            :  *
    4186                 :            :  * @param priv
    4187                 :            :  *   Pointer to private structure.
    4188                 :            :  */
    4189                 :            : void
    4190                 :          0 : dpaa2_flow_clean(struct rte_eth_dev *dev)
    4191                 :            : {
    4192                 :            :         struct rte_flow *flow;
    4193                 :          0 :         struct dpaa2_dev_priv *priv = dev->data->dev_private;
    4194                 :            : 
    4195         [ #  # ]:          0 :         while ((flow = LIST_FIRST(&priv->flows)))
    4196                 :          0 :                 dpaa2_flow_destroy(dev, flow, NULL);
    4197                 :          0 : }
    4198                 :            : 
    4199                 :            : const struct rte_flow_ops dpaa2_flow_ops = {
    4200                 :            :         .create = dpaa2_flow_create,
    4201                 :            :         .validate = dpaa2_flow_validate,
    4202                 :            :         .destroy = dpaa2_flow_destroy,
    4203                 :            :         .flush  = dpaa2_flow_flush,
    4204                 :            :         .query  = dpaa2_flow_query,
    4205                 :            : };

Generated by: LCOV version 1.14