LCOV - code coverage report
Current view: top level - drivers/net/ice - ice_hash.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 3 413 0.7 %
Date: 2024-01-22 15:55:54 Functions: 1 17 5.9 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 296 0.0 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright(c) 2019 Intel Corporation
       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_debug.h>
      14                 :            : #include <rte_ether.h>
      15                 :            : #include <ethdev_driver.h>
      16                 :            : #include <rte_log.h>
      17                 :            : #include <rte_malloc.h>
      18                 :            : #include <rte_eth_ctrl.h>
      19                 :            : #include <rte_tailq.h>
      20                 :            : #include <rte_flow_driver.h>
      21                 :            : 
      22                 :            : #include "ice_logs.h"
      23                 :            : #include "base/ice_type.h"
      24                 :            : #include "base/ice_flow.h"
      25                 :            : #include "ice_ethdev.h"
      26                 :            : #include "ice_generic_flow.h"
      27                 :            : 
      28                 :            : #define ICE_PHINT_NONE                          0
      29                 :            : #define ICE_PHINT_VLAN                          BIT_ULL(0)
      30                 :            : #define ICE_PHINT_PPPOE                         BIT_ULL(1)
      31                 :            : #define ICE_PHINT_GTPU                          BIT_ULL(2)
      32                 :            : #define ICE_PHINT_GTPU_EH                       BIT_ULL(3)
      33                 :            : #define ICE_PHINT_GTPU_EH_DWN                   BIT_ULL(4)
      34                 :            : #define ICE_PHINT_GTPU_EH_UP                    BIT_ULL(5)
      35                 :            : #define ICE_PHINT_RAW                           BIT_ULL(6)
      36                 :            : 
      37                 :            : #define ICE_GTPU_EH_DWNLINK     0
      38                 :            : #define ICE_GTPU_EH_UPLINK      1
      39                 :            : 
      40                 :            : #define ICE_IPV4_PROT           BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_PROT)
      41                 :            : #define ICE_IPV6_PROT           BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PROT)
      42                 :            : 
      43                 :            : #define VALID_RSS_IPV4_L4       (RTE_ETH_RSS_NONFRAG_IPV4_UDP   | \
      44                 :            :                                  RTE_ETH_RSS_NONFRAG_IPV4_TCP   | \
      45                 :            :                                  RTE_ETH_RSS_NONFRAG_IPV4_SCTP)
      46                 :            : 
      47                 :            : #define VALID_RSS_IPV6_L4       (RTE_ETH_RSS_NONFRAG_IPV6_UDP   | \
      48                 :            :                                  RTE_ETH_RSS_NONFRAG_IPV6_TCP   | \
      49                 :            :                                  RTE_ETH_RSS_NONFRAG_IPV6_SCTP)
      50                 :            : 
      51                 :            : #define VALID_RSS_IPV4          (RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_FRAG_IPV4 | \
      52                 :            :                                  VALID_RSS_IPV4_L4)
      53                 :            : #define VALID_RSS_IPV6          (RTE_ETH_RSS_IPV6 | RTE_ETH_RSS_FRAG_IPV6 | \
      54                 :            :                                  VALID_RSS_IPV6_L4)
      55                 :            : #define VALID_RSS_L3            (VALID_RSS_IPV4 | VALID_RSS_IPV6)
      56                 :            : #define VALID_RSS_L4            (VALID_RSS_IPV4_L4 | VALID_RSS_IPV6_L4)
      57                 :            : 
      58                 :            : #define VALID_RSS_ATTR          (RTE_ETH_RSS_L3_SRC_ONLY        | \
      59                 :            :                                  RTE_ETH_RSS_L3_DST_ONLY        | \
      60                 :            :                                  RTE_ETH_RSS_L4_SRC_ONLY        | \
      61                 :            :                                  RTE_ETH_RSS_L4_DST_ONLY        | \
      62                 :            :                                  RTE_ETH_RSS_L2_SRC_ONLY        | \
      63                 :            :                                  RTE_ETH_RSS_L2_DST_ONLY        | \
      64                 :            :                                  RTE_ETH_RSS_L3_PRE32   | \
      65                 :            :                                  RTE_ETH_RSS_L3_PRE48   | \
      66                 :            :                                  RTE_ETH_RSS_L3_PRE64)
      67                 :            : 
      68                 :            : #define INVALID_RSS_ATTR        (RTE_ETH_RSS_L3_PRE40   | \
      69                 :            :                                  RTE_ETH_RSS_L3_PRE56   | \
      70                 :            :                                  RTE_ETH_RSS_L3_PRE96)
      71                 :            : 
      72                 :            : struct ice_rss_meta {
      73                 :            :         uint8_t hash_function;
      74                 :            :         struct ice_rss_hash_cfg cfg;
      75                 :            :         struct ice_rss_raw_cfg raw;
      76                 :            : };
      77                 :            : 
      78                 :            : struct ice_hash_flow_cfg {
      79                 :            :         bool simple_xor;
      80                 :            :         struct ice_rss_cfg rss_cfg;
      81                 :            : };
      82                 :            : 
      83                 :            : static int
      84                 :            : ice_hash_init(struct ice_adapter *ad);
      85                 :            : 
      86                 :            : static int
      87                 :            : ice_hash_create(struct ice_adapter *ad,
      88                 :            :                 struct rte_flow *flow,
      89                 :            :                 void *meta,
      90                 :            :                 struct rte_flow_error *error);
      91                 :            : 
      92                 :            : static int
      93                 :            : ice_hash_destroy(struct ice_adapter *ad,
      94                 :            :                 struct rte_flow *flow,
      95                 :            :                 struct rte_flow_error *error);
      96                 :            : 
      97                 :            : static void
      98                 :            : ice_hash_uninit(struct ice_adapter *ad);
      99                 :            : 
     100                 :            : static void
     101                 :            : ice_hash_free(struct rte_flow *flow);
     102                 :            : 
     103                 :            : static int
     104                 :            : ice_hash_parse_pattern_action(struct ice_adapter *ad,
     105                 :            :                         struct ice_pattern_match_item *array,
     106                 :            :                         uint32_t array_len,
     107                 :            :                         const struct rte_flow_item pattern[],
     108                 :            :                         const struct rte_flow_action actions[],
     109                 :            :                         uint32_t priority,
     110                 :            :                         void **meta,
     111                 :            :                         struct rte_flow_error *error);
     112                 :            : 
     113                 :            : /* Rss configuration template */
     114                 :            : struct ice_rss_hash_cfg ipv4_tmplt = {
     115                 :            :         ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV4 |
     116                 :            :         ICE_FLOW_SEG_HDR_IPV_OTHER,
     117                 :            :         ICE_FLOW_HASH_ETH | ICE_FLOW_HASH_IPV4,
     118                 :            :         ICE_RSS_OUTER_HEADERS,
     119                 :            :         0
     120                 :            : };
     121                 :            : 
     122                 :            : struct ice_rss_hash_cfg ipv4_udp_tmplt = {
     123                 :            :         ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV4 |
     124                 :            :         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_UDP,
     125                 :            :         ICE_FLOW_HASH_ETH | ICE_HASH_UDP_IPV4 | ICE_IPV4_PROT,
     126                 :            :         ICE_RSS_OUTER_HEADERS,
     127                 :            :         0
     128                 :            : };
     129                 :            : 
     130                 :            : struct ice_rss_hash_cfg ipv4_tcp_tmplt = {
     131                 :            :         ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV4 |
     132                 :            :         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_TCP,
     133                 :            :         ICE_FLOW_HASH_ETH | ICE_HASH_TCP_IPV4 | ICE_IPV4_PROT,
     134                 :            :         ICE_RSS_OUTER_HEADERS,
     135                 :            :         0
     136                 :            : };
     137                 :            : 
     138                 :            : struct ice_rss_hash_cfg ipv4_sctp_tmplt = {
     139                 :            :         ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV4 |
     140                 :            :         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_SCTP,
     141                 :            :         ICE_FLOW_HASH_ETH | ICE_HASH_SCTP_IPV4 | ICE_IPV4_PROT,
     142                 :            :         ICE_RSS_OUTER_HEADERS,
     143                 :            :         0
     144                 :            : };
     145                 :            : 
     146                 :            : struct ice_rss_hash_cfg ipv6_tmplt = {
     147                 :            :         ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV6 |
     148                 :            :         ICE_FLOW_SEG_HDR_IPV_OTHER,
     149                 :            :         ICE_FLOW_HASH_ETH | ICE_FLOW_HASH_IPV6,
     150                 :            :         ICE_RSS_OUTER_HEADERS,
     151                 :            :         0
     152                 :            : };
     153                 :            : 
     154                 :            : struct ice_rss_hash_cfg ipv6_frag_tmplt = {
     155                 :            :         ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV6 |
     156                 :            :         ICE_FLOW_SEG_HDR_IPV_FRAG,
     157                 :            :         ICE_FLOW_HASH_ETH | ICE_FLOW_HASH_IPV6,
     158                 :            :         ICE_RSS_OUTER_HEADERS,
     159                 :            :         0
     160                 :            : };
     161                 :            : 
     162                 :            : struct ice_rss_hash_cfg ipv6_udp_tmplt = {
     163                 :            :         ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV6 |
     164                 :            :         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_UDP,
     165                 :            :         ICE_FLOW_HASH_ETH | ICE_HASH_UDP_IPV6 | ICE_IPV6_PROT,
     166                 :            :         ICE_RSS_OUTER_HEADERS,
     167                 :            :         0
     168                 :            : };
     169                 :            : 
     170                 :            : struct ice_rss_hash_cfg ipv6_tcp_tmplt = {
     171                 :            :         ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV6 |
     172                 :            :         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_TCP,
     173                 :            :         ICE_FLOW_HASH_ETH | ICE_HASH_TCP_IPV6 | ICE_IPV6_PROT,
     174                 :            :         ICE_RSS_OUTER_HEADERS,
     175                 :            :         0
     176                 :            : };
     177                 :            : 
     178                 :            : struct ice_rss_hash_cfg ipv6_sctp_tmplt = {
     179                 :            :         ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_IPV6 |
     180                 :            :         ICE_FLOW_SEG_HDR_IPV_OTHER | ICE_FLOW_SEG_HDR_SCTP,
     181                 :            :         ICE_FLOW_HASH_ETH | ICE_HASH_SCTP_IPV6 | ICE_IPV6_PROT,
     182                 :            :         ICE_RSS_OUTER_HEADERS,
     183                 :            :         0
     184                 :            : };
     185                 :            : 
     186                 :            : struct ice_rss_hash_cfg outer_ipv4_inner_ipv4_tmplt = {
     187                 :            :         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER,
     188                 :            :         ICE_FLOW_HASH_IPV4,
     189                 :            :         ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
     190                 :            :         0
     191                 :            : };
     192                 :            : struct ice_rss_hash_cfg outer_ipv4_inner_ipv4_udp_tmplt = {
     193                 :            :         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
     194                 :            :         ICE_FLOW_SEG_HDR_UDP,
     195                 :            :         ICE_HASH_UDP_IPV4 | ICE_IPV4_PROT,
     196                 :            :         ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
     197                 :            :         0
     198                 :            : };
     199                 :            : 
     200                 :            : struct ice_rss_hash_cfg outer_ipv4_inner_ipv4_tcp_tmplt = {
     201                 :            :         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
     202                 :            :         ICE_FLOW_SEG_HDR_TCP,
     203                 :            :         ICE_HASH_TCP_IPV4 | ICE_IPV4_PROT,
     204                 :            :         ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
     205                 :            :         0
     206                 :            : };
     207                 :            : 
     208                 :            : struct ice_rss_hash_cfg outer_ipv6_inner_ipv4_tmplt = {
     209                 :            :         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER,
     210                 :            :         ICE_FLOW_HASH_IPV4,
     211                 :            :         ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
     212                 :            :         0
     213                 :            : };
     214                 :            : 
     215                 :            : struct ice_rss_hash_cfg outer_ipv6_inner_ipv4_udp_tmplt = {
     216                 :            :         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
     217                 :            :         ICE_FLOW_SEG_HDR_UDP,
     218                 :            :         ICE_HASH_UDP_IPV4 | ICE_IPV4_PROT,
     219                 :            :         ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
     220                 :            :         0
     221                 :            : };
     222                 :            : 
     223                 :            : struct ice_rss_hash_cfg outer_ipv6_inner_ipv4_tcp_tmplt = {
     224                 :            :         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
     225                 :            :         ICE_FLOW_SEG_HDR_TCP,
     226                 :            :         ICE_HASH_TCP_IPV4 | ICE_IPV4_PROT,
     227                 :            :         ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
     228                 :            :         0
     229                 :            : };
     230                 :            : 
     231                 :            : struct ice_rss_hash_cfg outer_ipv4_inner_ipv6_tmplt = {
     232                 :            :         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER,
     233                 :            :         ICE_FLOW_HASH_IPV6,
     234                 :            :         ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
     235                 :            :         0
     236                 :            : };
     237                 :            : 
     238                 :            : struct ice_rss_hash_cfg outer_ipv4_inner_ipv6_udp_tmplt = {
     239                 :            :         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
     240                 :            :         ICE_FLOW_SEG_HDR_UDP,
     241                 :            :         ICE_HASH_UDP_IPV6 | ICE_IPV6_PROT,
     242                 :            :         ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
     243                 :            :         0
     244                 :            : };
     245                 :            : 
     246                 :            : struct ice_rss_hash_cfg outer_ipv4_inner_ipv6_tcp_tmplt = {
     247                 :            :         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
     248                 :            :         ICE_FLOW_SEG_HDR_TCP,
     249                 :            :         ICE_HASH_TCP_IPV6 | ICE_IPV6_PROT,
     250                 :            :         ICE_RSS_INNER_HEADERS_W_OUTER_IPV4,
     251                 :            :         0
     252                 :            : };
     253                 :            : 
     254                 :            : struct ice_rss_hash_cfg outer_ipv6_inner_ipv6_tmplt = {
     255                 :            :         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER,
     256                 :            :         ICE_FLOW_HASH_IPV6,
     257                 :            :         ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
     258                 :            :         0
     259                 :            : };
     260                 :            : struct ice_rss_hash_cfg outer_ipv6_inner_ipv6_udp_tmplt = {
     261                 :            :         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
     262                 :            :         ICE_FLOW_SEG_HDR_UDP,
     263                 :            :         ICE_HASH_UDP_IPV6 | ICE_IPV6_PROT,
     264                 :            :         ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
     265                 :            :         0
     266                 :            : };
     267                 :            : 
     268                 :            : struct ice_rss_hash_cfg outer_ipv6_inner_ipv6_tcp_tmplt = {
     269                 :            :         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
     270                 :            :         ICE_FLOW_SEG_HDR_TCP,
     271                 :            :         ICE_HASH_TCP_IPV6 | ICE_IPV6_PROT,
     272                 :            :         ICE_RSS_INNER_HEADERS_W_OUTER_IPV6,
     273                 :            :         0
     274                 :            : };
     275                 :            : 
     276                 :            : struct ice_rss_hash_cfg eth_ipv4_esp_tmplt = {
     277                 :            :         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
     278                 :            :         ICE_FLOW_SEG_HDR_ESP,
     279                 :            :         ICE_FLOW_HASH_ESP_SPI,
     280                 :            :         ICE_RSS_OUTER_HEADERS,
     281                 :            :         0
     282                 :            : };
     283                 :            : 
     284                 :            : struct ice_rss_hash_cfg eth_ipv4_udp_esp_tmplt = {
     285                 :            :         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
     286                 :            :         ICE_FLOW_SEG_HDR_NAT_T_ESP,
     287                 :            :         ICE_FLOW_HASH_NAT_T_ESP_SPI,
     288                 :            :         ICE_RSS_OUTER_HEADERS,
     289                 :            :         0
     290                 :            : };
     291                 :            : 
     292                 :            : struct ice_rss_hash_cfg eth_ipv4_ah_tmplt = {
     293                 :            :         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
     294                 :            :         ICE_FLOW_SEG_HDR_AH,
     295                 :            :         ICE_FLOW_HASH_AH_SPI,
     296                 :            :         ICE_RSS_OUTER_HEADERS,
     297                 :            :         0
     298                 :            : };
     299                 :            : 
     300                 :            : struct ice_rss_hash_cfg eth_ipv4_l2tpv3_tmplt = {
     301                 :            :         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
     302                 :            :         ICE_FLOW_SEG_HDR_L2TPV3,
     303                 :            :         ICE_FLOW_HASH_L2TPV3_SESS_ID,
     304                 :            :         ICE_RSS_OUTER_HEADERS,
     305                 :            :         0
     306                 :            : };
     307                 :            : 
     308                 :            : struct ice_rss_hash_cfg eth_ipv4_pfcp_tmplt = {
     309                 :            :         ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER |
     310                 :            :         ICE_FLOW_SEG_HDR_PFCP_SESSION,
     311                 :            :         ICE_FLOW_HASH_PFCP_SEID,
     312                 :            :         ICE_RSS_OUTER_HEADERS,
     313                 :            :         0
     314                 :            : };
     315                 :            : 
     316                 :            : struct ice_rss_hash_cfg eth_ipv6_esp_tmplt = {
     317                 :            :         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
     318                 :            :         ICE_FLOW_SEG_HDR_ESP,
     319                 :            :         ICE_FLOW_HASH_ESP_SPI,
     320                 :            :         ICE_RSS_OUTER_HEADERS,
     321                 :            :         0
     322                 :            : };
     323                 :            : 
     324                 :            : struct ice_rss_hash_cfg eth_ipv6_udp_esp_tmplt = {
     325                 :            :         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
     326                 :            :         ICE_FLOW_SEG_HDR_NAT_T_ESP,
     327                 :            :         ICE_FLOW_HASH_NAT_T_ESP_SPI,
     328                 :            :         ICE_RSS_OUTER_HEADERS,
     329                 :            :         0
     330                 :            : };
     331                 :            : 
     332                 :            : struct ice_rss_hash_cfg eth_ipv6_ah_tmplt = {
     333                 :            :         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
     334                 :            :         ICE_FLOW_SEG_HDR_AH,
     335                 :            :         ICE_FLOW_HASH_AH_SPI,
     336                 :            :         ICE_RSS_OUTER_HEADERS,
     337                 :            :         0
     338                 :            : };
     339                 :            : 
     340                 :            : struct ice_rss_hash_cfg eth_ipv6_l2tpv3_tmplt = {
     341                 :            :         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
     342                 :            :         ICE_FLOW_SEG_HDR_L2TPV3,
     343                 :            :         ICE_FLOW_HASH_L2TPV3_SESS_ID,
     344                 :            :         ICE_RSS_OUTER_HEADERS,
     345                 :            :         0
     346                 :            : };
     347                 :            : 
     348                 :            : struct ice_rss_hash_cfg eth_ipv6_pfcp_tmplt = {
     349                 :            :         ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER |
     350                 :            :         ICE_FLOW_SEG_HDR_PFCP_SESSION,
     351                 :            :         ICE_FLOW_HASH_PFCP_SEID,
     352                 :            :         ICE_RSS_OUTER_HEADERS,
     353                 :            :         0
     354                 :            : };
     355                 :            : 
     356                 :            : struct ice_rss_hash_cfg pppoe_tmplt = {
     357                 :            :         ICE_FLOW_SEG_HDR_ETH,
     358                 :            :         ICE_FLOW_HASH_ETH | ICE_FLOW_HASH_PPPOE_SESS_ID,
     359                 :            :         ICE_RSS_OUTER_HEADERS,
     360                 :            :         0
     361                 :            : };
     362                 :            : 
     363                 :            : struct ice_rss_hash_cfg empty_tmplt = {
     364                 :            :         ICE_FLOW_SEG_HDR_NONE,
     365                 :            :         0,
     366                 :            :         ICE_RSS_ANY_HEADERS,
     367                 :            :         0
     368                 :            : };
     369                 :            : 
     370                 :            : struct ice_rss_hash_cfg eth_tmplt = {
     371                 :            :         ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_ETH_NON_IP,
     372                 :            :         ICE_FLOW_HASH_ETH,
     373                 :            :         ICE_RSS_OUTER_HEADERS,
     374                 :            :         0
     375                 :            : };
     376                 :            : 
     377                 :            : /* IPv4 */
     378                 :            : #define ICE_RSS_TYPE_ETH_IPV4           (RTE_ETH_RSS_ETH | RTE_ETH_RSS_IPV4 | \
     379                 :            :                                          RTE_ETH_RSS_FRAG_IPV4 | \
     380                 :            :                                          RTE_ETH_RSS_IPV4_CHKSUM)
     381                 :            : #define ICE_RSS_TYPE_ETH_IPV4_UDP       (ICE_RSS_TYPE_ETH_IPV4 | \
     382                 :            :                                          RTE_ETH_RSS_NONFRAG_IPV4_UDP | \
     383                 :            :                                          RTE_ETH_RSS_L4_CHKSUM)
     384                 :            : #define ICE_RSS_TYPE_ETH_IPV4_TCP       (ICE_RSS_TYPE_ETH_IPV4 | \
     385                 :            :                                          RTE_ETH_RSS_NONFRAG_IPV4_TCP | \
     386                 :            :                                          RTE_ETH_RSS_L4_CHKSUM)
     387                 :            : #define ICE_RSS_TYPE_ETH_IPV4_SCTP      (ICE_RSS_TYPE_ETH_IPV4 | \
     388                 :            :                                          RTE_ETH_RSS_NONFRAG_IPV4_SCTP | \
     389                 :            :                                          RTE_ETH_RSS_L4_CHKSUM)
     390                 :            : #define ICE_RSS_TYPE_IPV4               RTE_ETH_RSS_IPV4
     391                 :            : #define ICE_RSS_TYPE_IPV4_UDP           (RTE_ETH_RSS_IPV4 | \
     392                 :            :                                          RTE_ETH_RSS_NONFRAG_IPV4_UDP)
     393                 :            : #define ICE_RSS_TYPE_IPV4_TCP           (RTE_ETH_RSS_IPV4 | \
     394                 :            :                                          RTE_ETH_RSS_NONFRAG_IPV4_TCP)
     395                 :            : #define ICE_RSS_TYPE_IPV4_SCTP          (RTE_ETH_RSS_IPV4 | \
     396                 :            :                                          RTE_ETH_RSS_NONFRAG_IPV4_SCTP)
     397                 :            : 
     398                 :            : /* IPv6 */
     399                 :            : #define ICE_RSS_TYPE_ETH_IPV6           (RTE_ETH_RSS_ETH | RTE_ETH_RSS_IPV6)
     400                 :            : #define ICE_RSS_TYPE_ETH_IPV6_FRAG      (RTE_ETH_RSS_ETH | RTE_ETH_RSS_IPV6 | \
     401                 :            :                                          RTE_ETH_RSS_FRAG_IPV6)
     402                 :            : #define ICE_RSS_TYPE_ETH_IPV6_UDP       (ICE_RSS_TYPE_ETH_IPV6 | \
     403                 :            :                                          RTE_ETH_RSS_NONFRAG_IPV6_UDP | \
     404                 :            :                                          RTE_ETH_RSS_L4_CHKSUM)
     405                 :            : #define ICE_RSS_TYPE_ETH_IPV6_TCP       (ICE_RSS_TYPE_ETH_IPV6 | \
     406                 :            :                                          RTE_ETH_RSS_NONFRAG_IPV6_TCP | \
     407                 :            :                                          RTE_ETH_RSS_L4_CHKSUM)
     408                 :            : #define ICE_RSS_TYPE_ETH_IPV6_SCTP      (ICE_RSS_TYPE_ETH_IPV6 | \
     409                 :            :                                          RTE_ETH_RSS_NONFRAG_IPV6_SCTP | \
     410                 :            :                                          RTE_ETH_RSS_L4_CHKSUM)
     411                 :            : #define ICE_RSS_TYPE_IPV6               RTE_ETH_RSS_IPV6
     412                 :            : #define ICE_RSS_TYPE_IPV6_UDP           (RTE_ETH_RSS_IPV6 | \
     413                 :            :                                          RTE_ETH_RSS_NONFRAG_IPV6_UDP)
     414                 :            : #define ICE_RSS_TYPE_IPV6_TCP           (RTE_ETH_RSS_IPV6 | \
     415                 :            :                                          RTE_ETH_RSS_NONFRAG_IPV6_TCP)
     416                 :            : #define ICE_RSS_TYPE_IPV6_SCTP          (RTE_ETH_RSS_IPV6 | \
     417                 :            :                                          RTE_ETH_RSS_NONFRAG_IPV6_SCTP)
     418                 :            : 
     419                 :            : /* VLAN IPV4 */
     420                 :            : #define ICE_RSS_TYPE_VLAN_IPV4          (ICE_RSS_TYPE_IPV4 | \
     421                 :            :                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN | \
     422                 :            :                                          RTE_ETH_RSS_FRAG_IPV4)
     423                 :            : #define ICE_RSS_TYPE_VLAN_IPV4_UDP      (ICE_RSS_TYPE_IPV4_UDP | \
     424                 :            :                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
     425                 :            : #define ICE_RSS_TYPE_VLAN_IPV4_TCP      (ICE_RSS_TYPE_IPV4_TCP | \
     426                 :            :                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
     427                 :            : #define ICE_RSS_TYPE_VLAN_IPV4_SCTP     (ICE_RSS_TYPE_IPV4_SCTP | \
     428                 :            :                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
     429                 :            : /* VLAN IPv6 */
     430                 :            : #define ICE_RSS_TYPE_VLAN_IPV6          (ICE_RSS_TYPE_IPV6 | \
     431                 :            :                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
     432                 :            : #define ICE_RSS_TYPE_VLAN_IPV6_FRAG     (ICE_RSS_TYPE_IPV6 | \
     433                 :            :                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN | \
     434                 :            :                                          RTE_ETH_RSS_FRAG_IPV6)
     435                 :            : #define ICE_RSS_TYPE_VLAN_IPV6_UDP      (ICE_RSS_TYPE_IPV6_UDP | \
     436                 :            :                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
     437                 :            : #define ICE_RSS_TYPE_VLAN_IPV6_TCP      (ICE_RSS_TYPE_IPV6_TCP | \
     438                 :            :                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
     439                 :            : #define ICE_RSS_TYPE_VLAN_IPV6_SCTP     (ICE_RSS_TYPE_IPV6_SCTP | \
     440                 :            :                                          RTE_ETH_RSS_S_VLAN | RTE_ETH_RSS_C_VLAN)
     441                 :            : 
     442                 :            : /* GTPU IPv4 */
     443                 :            : #define ICE_RSS_TYPE_GTPU_IPV4          (ICE_RSS_TYPE_IPV4 | \
     444                 :            :                                          RTE_ETH_RSS_GTPU)
     445                 :            : #define ICE_RSS_TYPE_GTPU_IPV4_UDP      (ICE_RSS_TYPE_IPV4_UDP | \
     446                 :            :                                          RTE_ETH_RSS_GTPU)
     447                 :            : #define ICE_RSS_TYPE_GTPU_IPV4_TCP      (ICE_RSS_TYPE_IPV4_TCP | \
     448                 :            :                                          RTE_ETH_RSS_GTPU)
     449                 :            : /* GTPU IPv6 */
     450                 :            : #define ICE_RSS_TYPE_GTPU_IPV6          (ICE_RSS_TYPE_IPV6 | \
     451                 :            :                                          RTE_ETH_RSS_GTPU)
     452                 :            : #define ICE_RSS_TYPE_GTPU_IPV6_UDP      (ICE_RSS_TYPE_IPV6_UDP | \
     453                 :            :                                          RTE_ETH_RSS_GTPU)
     454                 :            : #define ICE_RSS_TYPE_GTPU_IPV6_TCP      (ICE_RSS_TYPE_IPV6_TCP | \
     455                 :            :                                          RTE_ETH_RSS_GTPU)
     456                 :            : 
     457                 :            : /* PPPOE */
     458                 :            : #define ICE_RSS_TYPE_PPPOE              (RTE_ETH_RSS_ETH | RTE_ETH_RSS_PPPOE)
     459                 :            : 
     460                 :            : /* PPPOE IPv4 */
     461                 :            : #define ICE_RSS_TYPE_PPPOE_IPV4         (ICE_RSS_TYPE_IPV4 | \
     462                 :            :                                          ICE_RSS_TYPE_PPPOE)
     463                 :            : #define ICE_RSS_TYPE_PPPOE_IPV4_UDP     (ICE_RSS_TYPE_IPV4_UDP | \
     464                 :            :                                          ICE_RSS_TYPE_PPPOE)
     465                 :            : #define ICE_RSS_TYPE_PPPOE_IPV4_TCP     (ICE_RSS_TYPE_IPV4_TCP | \
     466                 :            :                                          ICE_RSS_TYPE_PPPOE)
     467                 :            : 
     468                 :            : /* PPPOE IPv6 */
     469                 :            : #define ICE_RSS_TYPE_PPPOE_IPV6         (ICE_RSS_TYPE_IPV6 | \
     470                 :            :                                          ICE_RSS_TYPE_PPPOE)
     471                 :            : #define ICE_RSS_TYPE_PPPOE_IPV6_UDP     (ICE_RSS_TYPE_IPV6_UDP | \
     472                 :            :                                          ICE_RSS_TYPE_PPPOE)
     473                 :            : #define ICE_RSS_TYPE_PPPOE_IPV6_TCP     (ICE_RSS_TYPE_IPV6_TCP | \
     474                 :            :                                          ICE_RSS_TYPE_PPPOE)
     475                 :            : 
     476                 :            : /* ESP, AH, L2TPV3 and PFCP */
     477                 :            : #define ICE_RSS_TYPE_IPV4_ESP           (RTE_ETH_RSS_ESP | RTE_ETH_RSS_IPV4)
     478                 :            : #define ICE_RSS_TYPE_IPV6_ESP           (RTE_ETH_RSS_ESP | RTE_ETH_RSS_IPV6)
     479                 :            : #define ICE_RSS_TYPE_IPV4_AH            (RTE_ETH_RSS_AH | RTE_ETH_RSS_IPV4)
     480                 :            : #define ICE_RSS_TYPE_IPV6_AH            (RTE_ETH_RSS_AH | RTE_ETH_RSS_IPV6)
     481                 :            : #define ICE_RSS_TYPE_IPV4_L2TPV3        (RTE_ETH_RSS_L2TPV3 | RTE_ETH_RSS_IPV4)
     482                 :            : #define ICE_RSS_TYPE_IPV6_L2TPV3        (RTE_ETH_RSS_L2TPV3 | RTE_ETH_RSS_IPV6)
     483                 :            : #define ICE_RSS_TYPE_IPV4_PFCP          (RTE_ETH_RSS_PFCP | RTE_ETH_RSS_IPV4)
     484                 :            : #define ICE_RSS_TYPE_IPV6_PFCP          (RTE_ETH_RSS_PFCP | RTE_ETH_RSS_IPV6)
     485                 :            : 
     486                 :            : /* MAC */
     487                 :            : #define ICE_RSS_TYPE_ETH                RTE_ETH_RSS_ETH
     488                 :            : 
     489                 :            : /**
     490                 :            :  * Supported pattern for hash.
     491                 :            :  * The first member is pattern item type,
     492                 :            :  * the second member is input set mask,
     493                 :            :  * the third member is ice_rss_hash_cfg template.
     494                 :            :  */
     495                 :            : static struct ice_pattern_match_item ice_hash_pattern_list[] = {
     496                 :            :         /* IPV4 */
     497                 :            :         {pattern_raw,                           ICE_INSET_NONE,                         ICE_INSET_NONE, NULL},
     498                 :            :         {pattern_eth_ipv4,                      ICE_RSS_TYPE_ETH_IPV4,          ICE_INSET_NONE, &ipv4_tmplt},
     499                 :            :         {pattern_eth_ipv4_udp,                  ICE_RSS_TYPE_ETH_IPV4_UDP,      ICE_INSET_NONE, &ipv4_udp_tmplt},
     500                 :            :         {pattern_eth_ipv4_tcp,                  ICE_RSS_TYPE_ETH_IPV4_TCP,      ICE_INSET_NONE, &ipv4_tcp_tmplt},
     501                 :            :         {pattern_eth_ipv4_sctp,                 ICE_RSS_TYPE_ETH_IPV4_SCTP,     ICE_INSET_NONE, &ipv4_sctp_tmplt},
     502                 :            :         {pattern_eth_vlan_ipv4,                 ICE_RSS_TYPE_VLAN_IPV4,         ICE_INSET_NONE, &ipv4_tmplt},
     503                 :            :         {pattern_eth_vlan_ipv4_udp,             ICE_RSS_TYPE_VLAN_IPV4_UDP,     ICE_INSET_NONE, &ipv4_udp_tmplt},
     504                 :            :         {pattern_eth_vlan_ipv4_tcp,             ICE_RSS_TYPE_VLAN_IPV4_TCP,     ICE_INSET_NONE, &ipv4_tcp_tmplt},
     505                 :            :         {pattern_eth_vlan_ipv4_sctp,            ICE_RSS_TYPE_VLAN_IPV4_SCTP,    ICE_INSET_NONE, &ipv4_sctp_tmplt},
     506                 :            :         {pattern_eth_ipv4_gtpu_ipv4,            ICE_RSS_TYPE_GTPU_IPV4,         ICE_INSET_NONE, &outer_ipv4_inner_ipv4_tmplt},
     507                 :            :         {pattern_eth_ipv4_gtpu_ipv4_udp,        ICE_RSS_TYPE_GTPU_IPV4_UDP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv4_udp_tmplt},
     508                 :            :         {pattern_eth_ipv4_gtpu_ipv4_tcp,        ICE_RSS_TYPE_GTPU_IPV4_TCP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv4_tcp_tmplt},
     509                 :            :         {pattern_eth_ipv6_gtpu_ipv4,            ICE_RSS_TYPE_GTPU_IPV4,         ICE_INSET_NONE, &outer_ipv6_inner_ipv4_tmplt},
     510                 :            :         {pattern_eth_ipv6_gtpu_ipv4_udp,        ICE_RSS_TYPE_GTPU_IPV4_UDP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv4_udp_tmplt},
     511                 :            :         {pattern_eth_ipv6_gtpu_ipv4_tcp,        ICE_RSS_TYPE_GTPU_IPV4_TCP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv4_tcp_tmplt},
     512                 :            :         {pattern_eth_ipv4_gtpu_eh_ipv4,         ICE_RSS_TYPE_GTPU_IPV4,         ICE_INSET_NONE, &outer_ipv4_inner_ipv4_tmplt},
     513                 :            :         {pattern_eth_ipv4_gtpu_eh_ipv4_udp,     ICE_RSS_TYPE_GTPU_IPV4_UDP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv4_udp_tmplt},
     514                 :            :         {pattern_eth_ipv4_gtpu_eh_ipv4_tcp,     ICE_RSS_TYPE_GTPU_IPV4_TCP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv4_tcp_tmplt},
     515                 :            :         {pattern_eth_ipv6_gtpu_eh_ipv4,         ICE_RSS_TYPE_GTPU_IPV4,         ICE_INSET_NONE, &outer_ipv6_inner_ipv4_tmplt},
     516                 :            :         {pattern_eth_ipv6_gtpu_eh_ipv4_udp,     ICE_RSS_TYPE_GTPU_IPV4_UDP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv4_udp_tmplt},
     517                 :            :         {pattern_eth_ipv6_gtpu_eh_ipv4_tcp,     ICE_RSS_TYPE_GTPU_IPV4_TCP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv4_tcp_tmplt},
     518                 :            :         {pattern_eth_pppoes_ipv4,               ICE_RSS_TYPE_PPPOE_IPV4,        ICE_INSET_NONE, &ipv4_tmplt},
     519                 :            :         {pattern_eth_pppoes_ipv4_udp,           ICE_RSS_TYPE_PPPOE_IPV4_UDP,    ICE_INSET_NONE, &ipv4_udp_tmplt},
     520                 :            :         {pattern_eth_pppoes_ipv4_tcp,           ICE_RSS_TYPE_PPPOE_IPV4_TCP,    ICE_INSET_NONE, &ipv4_tcp_tmplt},
     521                 :            :         {pattern_eth_ipv4_esp,                  ICE_RSS_TYPE_IPV4_ESP,          ICE_INSET_NONE, &eth_ipv4_esp_tmplt},
     522                 :            :         {pattern_eth_ipv4_udp_esp,              ICE_RSS_TYPE_IPV4_ESP,          ICE_INSET_NONE, &eth_ipv4_udp_esp_tmplt},
     523                 :            :         {pattern_eth_ipv4_ah,                   ICE_RSS_TYPE_IPV4_AH,           ICE_INSET_NONE, &eth_ipv4_ah_tmplt},
     524                 :            :         {pattern_eth_ipv4_l2tp,                 ICE_RSS_TYPE_IPV4_L2TPV3,       ICE_INSET_NONE, &eth_ipv4_l2tpv3_tmplt},
     525                 :            :         {pattern_eth_ipv4_pfcp,                 ICE_RSS_TYPE_IPV4_PFCP,         ICE_INSET_NONE, &eth_ipv4_pfcp_tmplt},
     526                 :            :         /* IPV6 */
     527                 :            :         {pattern_eth_ipv6,                      ICE_RSS_TYPE_ETH_IPV6,          ICE_INSET_NONE, &ipv6_tmplt},
     528                 :            :         {pattern_eth_ipv6_frag_ext,             ICE_RSS_TYPE_ETH_IPV6_FRAG,     ICE_INSET_NONE, &ipv6_frag_tmplt},
     529                 :            :         {pattern_eth_ipv6_udp,                  ICE_RSS_TYPE_ETH_IPV6_UDP,      ICE_INSET_NONE, &ipv6_udp_tmplt},
     530                 :            :         {pattern_eth_ipv6_tcp,                  ICE_RSS_TYPE_ETH_IPV6_TCP,      ICE_INSET_NONE, &ipv6_tcp_tmplt},
     531                 :            :         {pattern_eth_ipv6_sctp,                 ICE_RSS_TYPE_ETH_IPV6_SCTP,     ICE_INSET_NONE, &ipv6_sctp_tmplt},
     532                 :            :         {pattern_eth_vlan_ipv6,                 ICE_RSS_TYPE_VLAN_IPV6,         ICE_INSET_NONE, &ipv6_tmplt},
     533                 :            :         {pattern_eth_vlan_ipv6_frag_ext,        ICE_RSS_TYPE_VLAN_IPV6_FRAG,    ICE_INSET_NONE, &ipv6_frag_tmplt},
     534                 :            :         {pattern_eth_vlan_ipv6_udp,             ICE_RSS_TYPE_VLAN_IPV6_UDP,     ICE_INSET_NONE, &ipv6_udp_tmplt},
     535                 :            :         {pattern_eth_vlan_ipv6_tcp,             ICE_RSS_TYPE_VLAN_IPV6_TCP,     ICE_INSET_NONE, &ipv6_tcp_tmplt},
     536                 :            :         {pattern_eth_vlan_ipv6_sctp,            ICE_RSS_TYPE_VLAN_IPV6_SCTP,    ICE_INSET_NONE, &ipv6_sctp_tmplt},
     537                 :            :         {pattern_eth_ipv4_gtpu_ipv6,            ICE_RSS_TYPE_GTPU_IPV6,         ICE_INSET_NONE, &outer_ipv4_inner_ipv6_tmplt},
     538                 :            :         {pattern_eth_ipv4_gtpu_ipv6_udp,        ICE_RSS_TYPE_GTPU_IPV6_UDP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv6_udp_tmplt},
     539                 :            :         {pattern_eth_ipv4_gtpu_ipv6_tcp,        ICE_RSS_TYPE_GTPU_IPV6_TCP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv6_tcp_tmplt},
     540                 :            :         {pattern_eth_ipv6_gtpu_ipv6,            ICE_RSS_TYPE_GTPU_IPV6,         ICE_INSET_NONE, &outer_ipv6_inner_ipv6_tmplt},
     541                 :            :         {pattern_eth_ipv6_gtpu_ipv6_udp,        ICE_RSS_TYPE_GTPU_IPV6_UDP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv6_udp_tmplt},
     542                 :            :         {pattern_eth_ipv6_gtpu_ipv6_tcp,        ICE_RSS_TYPE_GTPU_IPV6_TCP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv6_tcp_tmplt},
     543                 :            :         {pattern_eth_ipv4_gtpu_eh_ipv6,         ICE_RSS_TYPE_GTPU_IPV6,         ICE_INSET_NONE, &outer_ipv4_inner_ipv6_tmplt},
     544                 :            :         {pattern_eth_ipv4_gtpu_eh_ipv6_udp,     ICE_RSS_TYPE_GTPU_IPV6_UDP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv6_udp_tmplt},
     545                 :            :         {pattern_eth_ipv4_gtpu_eh_ipv6_tcp,     ICE_RSS_TYPE_GTPU_IPV6_TCP,     ICE_INSET_NONE, &outer_ipv4_inner_ipv6_tcp_tmplt},
     546                 :            :         {pattern_eth_ipv6_gtpu_eh_ipv6,         ICE_RSS_TYPE_GTPU_IPV6,         ICE_INSET_NONE, &outer_ipv6_inner_ipv6_tmplt},
     547                 :            :         {pattern_eth_ipv6_gtpu_eh_ipv6_udp,     ICE_RSS_TYPE_GTPU_IPV6_UDP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv6_udp_tmplt},
     548                 :            :         {pattern_eth_ipv6_gtpu_eh_ipv6_tcp,     ICE_RSS_TYPE_GTPU_IPV6_TCP,     ICE_INSET_NONE, &outer_ipv6_inner_ipv6_tcp_tmplt},
     549                 :            :         {pattern_eth_pppoes_ipv6,               ICE_RSS_TYPE_PPPOE_IPV6,        ICE_INSET_NONE, &ipv6_tmplt},
     550                 :            :         {pattern_eth_pppoes_ipv6_udp,           ICE_RSS_TYPE_PPPOE_IPV6_UDP,    ICE_INSET_NONE, &ipv6_udp_tmplt},
     551                 :            :         {pattern_eth_pppoes_ipv6_tcp,           ICE_RSS_TYPE_PPPOE_IPV6_TCP,    ICE_INSET_NONE, &ipv6_tcp_tmplt},
     552                 :            :         {pattern_eth_ipv6_esp,                  ICE_RSS_TYPE_IPV6_ESP,          ICE_INSET_NONE, &eth_ipv6_esp_tmplt},
     553                 :            :         {pattern_eth_ipv6_udp_esp,              ICE_RSS_TYPE_IPV6_ESP,          ICE_INSET_NONE, &eth_ipv6_udp_esp_tmplt},
     554                 :            :         {pattern_eth_ipv6_ah,                   ICE_RSS_TYPE_IPV6_AH,           ICE_INSET_NONE, &eth_ipv6_ah_tmplt},
     555                 :            :         {pattern_eth_ipv6_l2tp,                 ICE_RSS_TYPE_IPV6_L2TPV3,       ICE_INSET_NONE, &eth_ipv6_l2tpv3_tmplt},
     556                 :            :         {pattern_eth_ipv6_pfcp,                 ICE_RSS_TYPE_IPV6_PFCP,         ICE_INSET_NONE, &eth_ipv6_pfcp_tmplt},
     557                 :            :         /* PPPOE */
     558                 :            :         {pattern_eth_pppoes,                    ICE_RSS_TYPE_PPPOE,             ICE_INSET_NONE, &pppoe_tmplt},
     559                 :            :         /* MAC */
     560                 :            :         {pattern_ethertype,                     ICE_RSS_TYPE_ETH,               ICE_INSET_NONE, &eth_tmplt},
     561                 :            :         /* EMPTY */
     562                 :            :         {pattern_empty,                         ICE_INSET_NONE,                 ICE_INSET_NONE, &empty_tmplt},
     563                 :            : };
     564                 :            : 
     565                 :            : static struct ice_flow_engine ice_hash_engine = {
     566                 :            :         .init = ice_hash_init,
     567                 :            :         .create = ice_hash_create,
     568                 :            :         .destroy = ice_hash_destroy,
     569                 :            :         .uninit = ice_hash_uninit,
     570                 :            :         .free = ice_hash_free,
     571                 :            :         .type = ICE_FLOW_ENGINE_HASH,
     572                 :            : };
     573                 :            : 
     574                 :            : /* Register parser for os package. */
     575                 :            : struct ice_flow_parser ice_hash_parser = {
     576                 :            :         .engine = &ice_hash_engine,
     577                 :            :         .array = ice_hash_pattern_list,
     578                 :            :         .array_len = RTE_DIM(ice_hash_pattern_list),
     579                 :            :         .parse_pattern_action = ice_hash_parse_pattern_action,
     580                 :            :         .stage = ICE_FLOW_STAGE_RSS,
     581                 :            : };
     582                 :            : 
     583                 :        235 : RTE_INIT(ice_hash_engine_init)
     584                 :            : {
     585                 :            :         struct ice_flow_engine *engine = &ice_hash_engine;
     586                 :        235 :         ice_register_flow_engine(engine);
     587                 :        235 : }
     588                 :            : 
     589                 :            : static int
     590                 :          0 : ice_hash_init(struct ice_adapter *ad __rte_unused)
     591                 :            : {
     592                 :          0 :         return 0;
     593                 :            : }
     594                 :            : 
     595                 :            : static int
     596                 :          0 : ice_hash_parse_pattern(const struct rte_flow_item pattern[], uint64_t *phint,
     597                 :            :                        struct rte_flow_error *error)
     598                 :            : {
     599                 :            :         const struct rte_flow_item *item = pattern;
     600                 :            :         const struct rte_flow_item_gtp_psc *psc;
     601                 :            : 
     602         [ #  # ]:          0 :         for (item = pattern; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
     603         [ #  # ]:          0 :                 if (item->last) {
     604                 :          0 :                         rte_flow_error_set(error, EINVAL,
     605                 :            :                                         RTE_FLOW_ERROR_TYPE_ITEM, item,
     606                 :            :                                         "Not support range");
     607                 :          0 :                         return -rte_errno;
     608                 :            :                 }
     609                 :            : 
     610   [ #  #  #  #  :          0 :                 switch (item->type) {
                   #  # ]
     611                 :          0 :                 case RTE_FLOW_ITEM_TYPE_RAW:
     612                 :          0 :                         *phint |= ICE_PHINT_RAW;
     613                 :          0 :                         break;
     614                 :          0 :                 case RTE_FLOW_ITEM_TYPE_VLAN:
     615                 :          0 :                         *phint |= ICE_PHINT_VLAN;
     616                 :          0 :                         break;
     617                 :          0 :                 case RTE_FLOW_ITEM_TYPE_PPPOES:
     618                 :          0 :                         *phint |= ICE_PHINT_PPPOE;
     619                 :          0 :                         break;
     620                 :          0 :                 case RTE_FLOW_ITEM_TYPE_GTPU:
     621                 :          0 :                         *phint |= ICE_PHINT_GTPU;
     622                 :          0 :                         break;
     623                 :          0 :                 case RTE_FLOW_ITEM_TYPE_GTP_PSC:
     624                 :          0 :                         *phint |= ICE_PHINT_GTPU_EH;
     625                 :          0 :                         psc = item->spec;
     626         [ #  # ]:          0 :                         if (!psc)
     627                 :            :                                 break;
     628         [ #  # ]:          0 :                         else if (psc->hdr.type == ICE_GTPU_EH_UPLINK)
     629                 :          0 :                                 *phint |= ICE_PHINT_GTPU_EH_UP;
     630         [ #  # ]:          0 :                         else if (psc->hdr.type == ICE_GTPU_EH_DWNLINK)
     631                 :          0 :                                 *phint |= ICE_PHINT_GTPU_EH_DWN;
     632                 :            :                         break;
     633                 :            :                 default:
     634                 :            :                         break;
     635                 :            :                 }
     636                 :            :         }
     637                 :            : 
     638                 :            :         return 0;
     639                 :            : }
     640                 :            : 
     641                 :            : static int
     642                 :          0 : ice_hash_parse_raw_pattern(struct ice_adapter *ad,
     643                 :            :                                 const struct rte_flow_item *item,
     644                 :            :                                 struct ice_rss_meta *meta)
     645                 :            : {
     646                 :            :         const struct rte_flow_item_raw *raw_spec, *raw_mask;
     647                 :            :         struct ice_parser_profile prof;
     648                 :            :         struct ice_parser_result rslt;
     649                 :            :         uint16_t spec_len, pkt_len;
     650                 :            :         uint8_t *pkt_buf, *msk_buf;
     651                 :            :         uint8_t tmp_val = 0;
     652                 :            :         uint8_t tmp_c = 0;
     653                 :            :         int i, j;
     654                 :            : 
     655         [ #  # ]:          0 :         if (ad->psr == NULL)
     656                 :          0 :                 return -rte_errno;
     657                 :            : 
     658                 :          0 :         raw_spec = item->spec;
     659                 :          0 :         raw_mask = item->mask;
     660                 :            : 
     661                 :          0 :         spec_len = strlen((char *)(uintptr_t)raw_spec->pattern);
     662         [ #  # ]:          0 :         if (strlen((char *)(uintptr_t)raw_mask->pattern) !=
     663                 :            :                 spec_len)
     664                 :          0 :                 return -rte_errno;
     665                 :            : 
     666                 :          0 :         pkt_len = spec_len / 2;
     667                 :            : 
     668                 :          0 :         pkt_buf = rte_zmalloc(NULL, pkt_len, 0);
     669         [ #  # ]:          0 :         if (!pkt_buf)
     670                 :            :                 return -ENOMEM;
     671                 :            : 
     672                 :          0 :         msk_buf = rte_zmalloc(NULL, pkt_len, 0);
     673         [ #  # ]:          0 :         if (!msk_buf)
     674                 :            :                 return -ENOMEM;
     675                 :            : 
     676                 :            :         /* convert string to int array */
     677         [ #  # ]:          0 :         for (i = 0, j = 0; i < spec_len; i += 2, j++) {
     678                 :          0 :                 tmp_c = raw_spec->pattern[i];
     679         [ #  # ]:          0 :                 if (tmp_c >= 'a' && tmp_c <= 'f')
     680                 :          0 :                         tmp_val = tmp_c - 'a' + 10;
     681         [ #  # ]:          0 :                 if (tmp_c >= 'A' && tmp_c <= 'F')
     682                 :          0 :                         tmp_val = tmp_c - 'A' + 10;
     683         [ #  # ]:          0 :                 if (tmp_c >= '0' && tmp_c <= '9')
     684                 :            :                         tmp_val = tmp_c - '0';
     685                 :            : 
     686                 :          0 :                 tmp_c = raw_spec->pattern[i + 1];
     687         [ #  # ]:          0 :                 if (tmp_c >= 'a' && tmp_c <= 'f')
     688                 :          0 :                         pkt_buf[j] = tmp_val * 16 + tmp_c - 'a' + 10;
     689         [ #  # ]:          0 :                 if (tmp_c >= 'A' && tmp_c <= 'F')
     690                 :          0 :                         pkt_buf[j] = tmp_val * 16 + tmp_c - 'A' + 10;
     691         [ #  # ]:          0 :                 if (tmp_c >= '0' && tmp_c <= '9')
     692                 :          0 :                         pkt_buf[j] = tmp_val * 16 + tmp_c - '0';
     693                 :            : 
     694                 :          0 :                 tmp_c = raw_mask->pattern[i];
     695         [ #  # ]:          0 :                 if (tmp_c >= 'a' && tmp_c <= 'f')
     696                 :          0 :                         tmp_val = tmp_c - 0x57;
     697         [ #  # ]:          0 :                 if (tmp_c >= 'A' && tmp_c <= 'F')
     698                 :          0 :                         tmp_val = tmp_c - 0x37;
     699         [ #  # ]:          0 :                 if (tmp_c >= '0' && tmp_c <= '9')
     700                 :            :                         tmp_val = tmp_c - '0';
     701                 :            : 
     702                 :          0 :                 tmp_c = raw_mask->pattern[i + 1];
     703         [ #  # ]:          0 :                 if (tmp_c >= 'a' && tmp_c <= 'f')
     704                 :          0 :                         msk_buf[j] = tmp_val * 16 + tmp_c - 'a' + 10;
     705         [ #  # ]:          0 :                 if (tmp_c >= 'A' && tmp_c <= 'F')
     706                 :          0 :                         msk_buf[j] = tmp_val * 16 + tmp_c - 'A' + 10;
     707         [ #  # ]:          0 :                 if (tmp_c >= '0' && tmp_c <= '9')
     708                 :          0 :                         msk_buf[j] = tmp_val * 16 + tmp_c - '0';
     709                 :            :         }
     710                 :            : 
     711         [ #  # ]:          0 :         if (ice_parser_run(ad->psr, pkt_buf, pkt_len, &rslt))
     712                 :          0 :                 return -rte_errno;
     713                 :            : 
     714         [ #  # ]:          0 :         if (ice_parser_profile_init(&rslt, pkt_buf, msk_buf,
     715                 :            :                 pkt_len, ICE_BLK_RSS, true, &prof))
     716                 :          0 :                 return -rte_errno;
     717                 :            : 
     718         [ #  # ]:          0 :         rte_memcpy(&meta->raw.prof, &prof, sizeof(prof));
     719                 :            : 
     720                 :          0 :         rte_free(pkt_buf);
     721                 :          0 :         rte_free(msk_buf);
     722                 :          0 :         return 0;
     723                 :            : }
     724                 :            : 
     725                 :            : static void
     726                 :          0 : ice_refine_hash_cfg_l234(struct ice_rss_hash_cfg *hash_cfg,
     727                 :            :                          uint64_t rss_type)
     728                 :            : {
     729                 :            :         uint32_t *addl_hdrs = &hash_cfg->addl_hdrs;
     730                 :            :         uint64_t *hash_flds = &hash_cfg->hash_flds;
     731                 :            : 
     732         [ #  # ]:          0 :         if (*addl_hdrs & ICE_FLOW_SEG_HDR_ETH) {
     733         [ #  # ]:          0 :                 if (!(rss_type & RTE_ETH_RSS_ETH))
     734                 :          0 :                         *hash_flds &= ~ICE_FLOW_HASH_ETH;
     735         [ #  # ]:          0 :                 if (rss_type & RTE_ETH_RSS_L2_SRC_ONLY)
     736                 :          0 :                         *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_ETH_DA));
     737         [ #  # ]:          0 :                 else if (rss_type & RTE_ETH_RSS_L2_DST_ONLY)
     738                 :          0 :                         *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_ETH_SA));
     739                 :          0 :                 *addl_hdrs &= ~ICE_FLOW_SEG_HDR_ETH;
     740                 :            :         }
     741                 :            : 
     742         [ #  # ]:          0 :         if (*addl_hdrs & ICE_FLOW_SEG_HDR_ETH_NON_IP) {
     743         [ #  # ]:          0 :                 if (rss_type & RTE_ETH_RSS_ETH)
     744                 :          0 :                         *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_ETH_TYPE);
     745                 :            :         }
     746                 :            : 
     747         [ #  # ]:          0 :         if (*addl_hdrs & ICE_FLOW_SEG_HDR_VLAN) {
     748         [ #  # ]:          0 :                 if (rss_type & RTE_ETH_RSS_C_VLAN)
     749                 :          0 :                         *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_C_VLAN);
     750         [ #  # ]:          0 :                 else if (rss_type & RTE_ETH_RSS_S_VLAN)
     751                 :          0 :                         *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_S_VLAN);
     752                 :            :         }
     753                 :            : 
     754         [ #  # ]:          0 :         if (*addl_hdrs & ICE_FLOW_SEG_HDR_PPPOE) {
     755         [ #  # ]:          0 :                 if (!(rss_type & RTE_ETH_RSS_PPPOE))
     756                 :          0 :                         *hash_flds &= ~ICE_FLOW_HASH_PPPOE_SESS_ID;
     757                 :            :         }
     758                 :            : 
     759         [ #  # ]:          0 :         if (*addl_hdrs & ICE_FLOW_SEG_HDR_IPV4) {
     760         [ #  # ]:          0 :                 if (rss_type &
     761                 :            :                    (RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_FRAG_IPV4 |
     762                 :            :                     RTE_ETH_RSS_NONFRAG_IPV4_UDP |
     763                 :            :                     RTE_ETH_RSS_NONFRAG_IPV4_TCP |
     764                 :            :                     RTE_ETH_RSS_NONFRAG_IPV4_SCTP)) {
     765         [ #  # ]:          0 :                         if (rss_type & RTE_ETH_RSS_FRAG_IPV4) {
     766                 :          0 :                                 *addl_hdrs |= ICE_FLOW_SEG_HDR_IPV_FRAG;
     767                 :          0 :                                 *addl_hdrs &= ~(ICE_FLOW_SEG_HDR_IPV_OTHER);
     768                 :          0 :                                 *hash_flds |=
     769                 :            :                                         BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_ID);
     770                 :            :                         }
     771         [ #  # ]:          0 :                         if (rss_type & RTE_ETH_RSS_L3_SRC_ONLY)
     772                 :          0 :                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA));
     773         [ #  # ]:          0 :                         else if (rss_type & RTE_ETH_RSS_L3_DST_ONLY)
     774                 :          0 :                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA));
     775         [ #  # ]:          0 :                         else if (rss_type &
     776                 :            :                                 (RTE_ETH_RSS_L4_SRC_ONLY |
     777                 :            :                                 RTE_ETH_RSS_L4_DST_ONLY))
     778                 :          0 :                                 *hash_flds &= ~ICE_FLOW_HASH_IPV4;
     779                 :            :                 } else {
     780                 :          0 :                         *hash_flds &= ~ICE_FLOW_HASH_IPV4;
     781                 :            :                 }
     782                 :            : 
     783         [ #  # ]:          0 :                 if (rss_type & RTE_ETH_RSS_IPV4_CHKSUM)
     784                 :          0 :                         *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_CHKSUM);
     785                 :            :         }
     786                 :            : 
     787         [ #  # ]:          0 :         if (*addl_hdrs & ICE_FLOW_SEG_HDR_IPV6) {
     788         [ #  # ]:          0 :                 if (rss_type &
     789                 :            :                    (RTE_ETH_RSS_IPV6 | RTE_ETH_RSS_FRAG_IPV6 |
     790                 :            :                     RTE_ETH_RSS_NONFRAG_IPV6_UDP |
     791                 :            :                     RTE_ETH_RSS_NONFRAG_IPV6_TCP |
     792                 :            :                     RTE_ETH_RSS_NONFRAG_IPV6_SCTP)) {
     793         [ #  # ]:          0 :                         if (rss_type & RTE_ETH_RSS_FRAG_IPV6)
     794                 :          0 :                                 *hash_flds |=
     795                 :            :                                         BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_ID);
     796         [ #  # ]:          0 :                         if (rss_type & RTE_ETH_RSS_L3_SRC_ONLY)
     797                 :          0 :                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA));
     798         [ #  # ]:          0 :                         else if (rss_type & RTE_ETH_RSS_L3_DST_ONLY)
     799                 :          0 :                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA));
     800         [ #  # ]:          0 :                         else if (rss_type &
     801                 :            :                                 (RTE_ETH_RSS_L4_SRC_ONLY |
     802                 :            :                                 RTE_ETH_RSS_L4_DST_ONLY))
     803                 :          0 :                                 *hash_flds &= ~ICE_FLOW_HASH_IPV6;
     804                 :            :                 } else {
     805                 :          0 :                         *hash_flds &= ~ICE_FLOW_HASH_IPV6;
     806                 :            :                 }
     807                 :            : 
     808         [ #  # ]:          0 :                 if (rss_type & RTE_ETH_RSS_L3_PRE32) {
     809         [ #  # ]:          0 :                         if (rss_type & RTE_ETH_RSS_L3_SRC_ONLY) {
     810                 :          0 :                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA));
     811                 :          0 :                                 *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE32_SA));
     812         [ #  # ]:          0 :                         } else if (rss_type & RTE_ETH_RSS_L3_DST_ONLY) {
     813                 :          0 :                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA));
     814                 :          0 :                                 *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE32_DA));
     815                 :            :                         } else {
     816                 :          0 :                                 *hash_flds &= ~ICE_FLOW_HASH_IPV6;
     817                 :          0 :                                 *hash_flds |= ICE_FLOW_HASH_IPV6_PRE32;
     818                 :            :                         }
     819                 :            :                 }
     820         [ #  # ]:          0 :                 if (rss_type & RTE_ETH_RSS_L3_PRE48) {
     821         [ #  # ]:          0 :                         if (rss_type & RTE_ETH_RSS_L3_SRC_ONLY) {
     822                 :          0 :                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA));
     823                 :          0 :                                 *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE48_SA));
     824         [ #  # ]:          0 :                         } else if (rss_type & RTE_ETH_RSS_L3_DST_ONLY) {
     825                 :          0 :                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA));
     826                 :          0 :                                 *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE48_DA));
     827                 :            :                         } else {
     828                 :          0 :                                 *hash_flds &= ~ICE_FLOW_HASH_IPV6;
     829                 :          0 :                                 *hash_flds |= ICE_FLOW_HASH_IPV6_PRE48;
     830                 :            :                         }
     831                 :            :                 }
     832         [ #  # ]:          0 :                 if (rss_type & RTE_ETH_RSS_L3_PRE64) {
     833         [ #  # ]:          0 :                         if (rss_type & RTE_ETH_RSS_L3_SRC_ONLY) {
     834                 :          0 :                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA));
     835                 :          0 :                                 *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE64_SA));
     836         [ #  # ]:          0 :                         } else if (rss_type & RTE_ETH_RSS_L3_DST_ONLY) {
     837                 :          0 :                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA));
     838                 :          0 :                                 *hash_flds |= (BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_PRE64_DA));
     839                 :            :                         } else {
     840                 :          0 :                                 *hash_flds &= ~ICE_FLOW_HASH_IPV6;
     841                 :          0 :                                 *hash_flds |= ICE_FLOW_HASH_IPV6_PRE64;
     842                 :            :                         }
     843                 :            :                 }
     844                 :            :         }
     845                 :            : 
     846         [ #  # ]:          0 :         if (*addl_hdrs & ICE_FLOW_SEG_HDR_UDP) {
     847         [ #  # ]:          0 :                 if (rss_type &
     848                 :            :                    (RTE_ETH_RSS_NONFRAG_IPV4_UDP |
     849                 :            :                     RTE_ETH_RSS_NONFRAG_IPV6_UDP)) {
     850         [ #  # ]:          0 :                         if (rss_type & RTE_ETH_RSS_L4_SRC_ONLY)
     851                 :          0 :                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_DST_PORT));
     852         [ #  # ]:          0 :                         else if (rss_type & RTE_ETH_RSS_L4_DST_ONLY)
     853                 :          0 :                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_SRC_PORT));
     854         [ #  # ]:          0 :                         else if (rss_type &
     855                 :            :                                 (RTE_ETH_RSS_L3_SRC_ONLY |
     856                 :            :                                   RTE_ETH_RSS_L3_DST_ONLY))
     857                 :          0 :                                 *hash_flds &= ~ICE_FLOW_HASH_UDP_PORT;
     858                 :            :                 } else {
     859                 :          0 :                         *hash_flds &= ~ICE_FLOW_HASH_UDP_PORT;
     860                 :            :                 }
     861                 :            : 
     862         [ #  # ]:          0 :                 if (rss_type & RTE_ETH_RSS_L4_CHKSUM)
     863                 :          0 :                         *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_CHKSUM);
     864                 :            :         }
     865                 :            : 
     866         [ #  # ]:          0 :         if (*addl_hdrs & ICE_FLOW_SEG_HDR_TCP) {
     867         [ #  # ]:          0 :                 if (rss_type &
     868                 :            :                    (RTE_ETH_RSS_NONFRAG_IPV4_TCP |
     869                 :            :                     RTE_ETH_RSS_NONFRAG_IPV6_TCP)) {
     870         [ #  # ]:          0 :                         if (rss_type & RTE_ETH_RSS_L4_SRC_ONLY)
     871                 :          0 :                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_DST_PORT));
     872         [ #  # ]:          0 :                         else if (rss_type & RTE_ETH_RSS_L4_DST_ONLY)
     873                 :          0 :                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_SRC_PORT));
     874         [ #  # ]:          0 :                         else if (rss_type &
     875                 :            :                                 (RTE_ETH_RSS_L3_SRC_ONLY |
     876                 :            :                                   RTE_ETH_RSS_L3_DST_ONLY))
     877                 :          0 :                                 *hash_flds &= ~ICE_FLOW_HASH_TCP_PORT;
     878                 :            :                 } else {
     879                 :          0 :                         *hash_flds &= ~ICE_FLOW_HASH_TCP_PORT;
     880                 :            :                 }
     881                 :            : 
     882         [ #  # ]:          0 :                 if (rss_type & RTE_ETH_RSS_L4_CHKSUM)
     883                 :          0 :                         *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_CHKSUM);
     884                 :            :         }
     885                 :            : 
     886         [ #  # ]:          0 :         if (*addl_hdrs & ICE_FLOW_SEG_HDR_SCTP) {
     887         [ #  # ]:          0 :                 if (rss_type &
     888                 :            :                    (RTE_ETH_RSS_NONFRAG_IPV4_SCTP |
     889                 :            :                     RTE_ETH_RSS_NONFRAG_IPV6_SCTP)) {
     890         [ #  # ]:          0 :                         if (rss_type & RTE_ETH_RSS_L4_SRC_ONLY)
     891                 :          0 :                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_DST_PORT));
     892         [ #  # ]:          0 :                         else if (rss_type & RTE_ETH_RSS_L4_DST_ONLY)
     893                 :          0 :                                 *hash_flds &= ~(BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT));
     894         [ #  # ]:          0 :                         else if (rss_type &
     895                 :            :                                 (RTE_ETH_RSS_L3_SRC_ONLY |
     896                 :            :                                   RTE_ETH_RSS_L3_DST_ONLY))
     897                 :          0 :                                 *hash_flds &= ~ICE_FLOW_HASH_SCTP_PORT;
     898                 :            :                 } else {
     899                 :          0 :                         *hash_flds &= ~ICE_FLOW_HASH_SCTP_PORT;
     900                 :            :                 }
     901                 :            : 
     902         [ #  # ]:          0 :                 if (rss_type & RTE_ETH_RSS_L4_CHKSUM)
     903                 :          0 :                         *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_CHKSUM);
     904                 :            :         }
     905                 :            : 
     906         [ #  # ]:          0 :         if (*addl_hdrs & ICE_FLOW_SEG_HDR_L2TPV3) {
     907         [ #  # ]:          0 :                 if (!(rss_type & RTE_ETH_RSS_L2TPV3))
     908                 :          0 :                         *hash_flds &= ~ICE_FLOW_HASH_L2TPV3_SESS_ID;
     909                 :            :         }
     910                 :            : 
     911         [ #  # ]:          0 :         if (*addl_hdrs & ICE_FLOW_SEG_HDR_ESP) {
     912         [ #  # ]:          0 :                 if (!(rss_type & RTE_ETH_RSS_ESP))
     913                 :          0 :                         *hash_flds &= ~ICE_FLOW_HASH_ESP_SPI;
     914                 :            :         }
     915                 :            : 
     916         [ #  # ]:          0 :         if (*addl_hdrs & ICE_FLOW_SEG_HDR_AH) {
     917         [ #  # ]:          0 :                 if (!(rss_type & RTE_ETH_RSS_AH))
     918                 :          0 :                         *hash_flds &= ~ICE_FLOW_HASH_AH_SPI;
     919                 :            :         }
     920                 :            : 
     921         [ #  # ]:          0 :         if (*addl_hdrs & ICE_FLOW_SEG_HDR_PFCP_SESSION) {
     922         [ #  # ]:          0 :                 if (!(rss_type & RTE_ETH_RSS_PFCP))
     923                 :          0 :                         *hash_flds &= ~ICE_FLOW_HASH_PFCP_SEID;
     924                 :            :         }
     925                 :          0 : }
     926                 :            : 
     927                 :            : static void
     928                 :          0 : ice_refine_proto_hdrs_by_pattern(struct ice_rss_hash_cfg *hash_cfg,
     929                 :            :                                  uint64_t phint)
     930                 :            : {
     931                 :            :         uint32_t *addl_hdrs = &hash_cfg->addl_hdrs;
     932         [ #  # ]:          0 :         if (phint & ICE_PHINT_VLAN)
     933                 :          0 :                 *addl_hdrs |= ICE_FLOW_SEG_HDR_VLAN;
     934                 :            : 
     935         [ #  # ]:          0 :         if (phint & ICE_PHINT_PPPOE)
     936                 :          0 :                 *addl_hdrs |= ICE_FLOW_SEG_HDR_PPPOE;
     937                 :            : 
     938         [ #  # ]:          0 :         if (phint & ICE_PHINT_GTPU_EH_DWN)
     939                 :          0 :                 *addl_hdrs |= ICE_FLOW_SEG_HDR_GTPU_DWN;
     940         [ #  # ]:          0 :         else if (phint & ICE_PHINT_GTPU_EH_UP)
     941                 :          0 :                 *addl_hdrs |= ICE_FLOW_SEG_HDR_GTPU_UP;
     942         [ #  # ]:          0 :         else if (phint & ICE_PHINT_GTPU_EH)
     943                 :          0 :                 *addl_hdrs |= ICE_FLOW_SEG_HDR_GTPU_EH;
     944         [ #  # ]:          0 :         else if (phint & ICE_PHINT_GTPU)
     945                 :          0 :                 *addl_hdrs |= ICE_FLOW_SEG_HDR_GTPU_IP;
     946                 :          0 : }
     947                 :            : 
     948                 :            : static void
     949                 :          0 : ice_refine_hash_cfg_gtpu(struct ice_rss_hash_cfg *hash_cfg,
     950                 :            :                          uint64_t rss_type)
     951                 :            : {
     952                 :            :         uint32_t *addl_hdrs = &hash_cfg->addl_hdrs;
     953                 :            :         uint64_t *hash_flds = &hash_cfg->hash_flds;
     954                 :            : 
     955                 :            :         /* update hash field for gtpu eh/gtpu dwn/gtpu up. */
     956         [ #  # ]:          0 :         if (!(rss_type & RTE_ETH_RSS_GTPU))
     957                 :            :                 return;
     958                 :            : 
     959         [ #  # ]:          0 :         if (*addl_hdrs & ICE_FLOW_SEG_HDR_GTPU_DWN)
     960                 :          0 :                 *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_GTPU_DWN_TEID);
     961         [ #  # ]:          0 :         else if (*addl_hdrs & ICE_FLOW_SEG_HDR_GTPU_UP)
     962                 :          0 :                 *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_GTPU_UP_TEID);
     963         [ #  # ]:          0 :         else if (*addl_hdrs & ICE_FLOW_SEG_HDR_GTPU_EH)
     964                 :          0 :                 *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_GTPU_EH_TEID);
     965         [ #  # ]:          0 :         else if (*addl_hdrs & ICE_FLOW_SEG_HDR_GTPU_IP)
     966                 :          0 :                 *hash_flds |= BIT_ULL(ICE_FLOW_FIELD_IDX_GTPU_IP_TEID);
     967                 :            : }
     968                 :            : 
     969                 :          0 : static void ice_refine_hash_cfg(struct ice_rss_hash_cfg *hash_cfg,
     970                 :            :                                 uint64_t rss_type, uint64_t phint)
     971                 :            : {
     972                 :          0 :         ice_refine_proto_hdrs_by_pattern(hash_cfg, phint);
     973                 :          0 :         ice_refine_hash_cfg_l234(hash_cfg, rss_type);
     974                 :          0 :         ice_refine_hash_cfg_gtpu(hash_cfg, rss_type);
     975                 :          0 : }
     976                 :            : 
     977                 :            : static uint64_t invalid_rss_comb[] = {
     978                 :            :         RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_NONFRAG_IPV4_UDP,
     979                 :            :         RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_NONFRAG_IPV4_TCP,
     980                 :            :         RTE_ETH_RSS_IPV6 | RTE_ETH_RSS_NONFRAG_IPV6_UDP,
     981                 :            :         RTE_ETH_RSS_IPV6 | RTE_ETH_RSS_NONFRAG_IPV6_TCP,
     982                 :            :         RTE_ETH_RSS_L3_PRE40 |
     983                 :            :         RTE_ETH_RSS_L3_PRE56 |
     984                 :            :         RTE_ETH_RSS_L3_PRE96
     985                 :            : };
     986                 :            : 
     987                 :            : struct rss_attr_type {
     988                 :            :         uint64_t attr;
     989                 :            :         uint64_t type;
     990                 :            : };
     991                 :            : 
     992                 :            : static struct rss_attr_type rss_attr_to_valid_type[] = {
     993                 :            :         {RTE_ETH_RSS_L2_SRC_ONLY | RTE_ETH_RSS_L2_DST_ONLY,     RTE_ETH_RSS_ETH},
     994                 :            :         {RTE_ETH_RSS_L3_SRC_ONLY | RTE_ETH_RSS_L3_DST_ONLY,     VALID_RSS_L3},
     995                 :            :         {RTE_ETH_RSS_L4_SRC_ONLY | RTE_ETH_RSS_L4_DST_ONLY,     VALID_RSS_L4},
     996                 :            :         /* current ipv6 prefix only supports prefix 64 bits*/
     997                 :            :         {RTE_ETH_RSS_L3_PRE32,                          VALID_RSS_IPV6},
     998                 :            :         {RTE_ETH_RSS_L3_PRE48,                          VALID_RSS_IPV6},
     999                 :            :         {RTE_ETH_RSS_L3_PRE64,                          VALID_RSS_IPV6},
    1000                 :            :         {INVALID_RSS_ATTR,                              0}
    1001                 :            : };
    1002                 :            : 
    1003                 :            : static bool
    1004                 :          0 : ice_any_invalid_rss_type(enum rte_eth_hash_function rss_func,
    1005                 :            :                          uint64_t rss_type, uint64_t allow_rss_type)
    1006                 :            : {
    1007                 :            :         uint32_t i;
    1008                 :            : 
    1009                 :            :         /**
    1010                 :            :          * Check if l3/l4 SRC/DST_ONLY is set for SYMMETRIC_TOEPLITZ
    1011                 :            :          * hash function.
    1012                 :            :          */
    1013         [ #  # ]:          0 :         if (rss_func == RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ) {
    1014         [ #  # ]:          0 :                 if (rss_type & (RTE_ETH_RSS_L3_SRC_ONLY | RTE_ETH_RSS_L3_DST_ONLY |
    1015                 :            :                     RTE_ETH_RSS_L4_SRC_ONLY | RTE_ETH_RSS_L4_DST_ONLY))
    1016                 :            :                         return true;
    1017                 :            : 
    1018         [ #  # ]:          0 :                 if (!(rss_type &
    1019                 :            :                    (RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_IPV6 |
    1020                 :            :                     RTE_ETH_RSS_FRAG_IPV4 | RTE_ETH_RSS_FRAG_IPV6 |
    1021                 :            :                     RTE_ETH_RSS_NONFRAG_IPV4_UDP | RTE_ETH_RSS_NONFRAG_IPV6_UDP |
    1022                 :            :                     RTE_ETH_RSS_NONFRAG_IPV4_TCP | RTE_ETH_RSS_NONFRAG_IPV6_TCP |
    1023                 :            :                     RTE_ETH_RSS_NONFRAG_IPV4_SCTP | RTE_ETH_RSS_NONFRAG_IPV6_SCTP)))
    1024                 :            :                         return true;
    1025                 :            :         }
    1026                 :            : 
    1027                 :            :         /* check invalid combination */
    1028         [ #  # ]:          0 :         for (i = 0; i < RTE_DIM(invalid_rss_comb); i++) {
    1029         [ #  # ]:          0 :                 if (rte_popcount64(rss_type & invalid_rss_comb[i]) > 1)
    1030                 :            :                         return true;
    1031                 :            :         }
    1032                 :            : 
    1033                 :            :         /* check invalid RSS attribute */
    1034         [ #  # ]:          0 :         for (i = 0; i < RTE_DIM(rss_attr_to_valid_type); i++) {
    1035                 :            :                 struct rss_attr_type *rat = &rss_attr_to_valid_type[i];
    1036                 :            : 
    1037   [ #  #  #  # ]:          0 :                 if (rat->attr & rss_type && !(rat->type & rss_type))
    1038                 :            :                         return true;
    1039                 :            :         }
    1040                 :            : 
    1041                 :            :         /* check not allowed RSS type */
    1042                 :          0 :         rss_type &= ~VALID_RSS_ATTR;
    1043                 :            : 
    1044                 :          0 :         return ((rss_type & allow_rss_type) != rss_type);
    1045                 :            : }
    1046                 :            : 
    1047                 :            : static int
    1048                 :          0 : ice_hash_parse_action(struct ice_pattern_match_item *pattern_match_item,
    1049                 :            :                 const struct rte_flow_action actions[],
    1050                 :            :                 uint64_t pattern_hint, struct ice_rss_meta *rss_meta,
    1051                 :            :                 struct rte_flow_error *error)
    1052                 :            : {
    1053                 :          0 :         struct ice_rss_hash_cfg *cfg = pattern_match_item->meta;
    1054                 :            :         enum rte_flow_action_type action_type;
    1055                 :            :         const struct rte_flow_action_rss *rss;
    1056                 :            :         const struct rte_flow_action *action;
    1057                 :            :         uint64_t rss_type;
    1058                 :            : 
    1059                 :            :         /* Supported action is RSS. */
    1060         [ #  # ]:          0 :         for (action = actions; action->type !=
    1061                 :          0 :                 RTE_FLOW_ACTION_TYPE_END; action++) {
    1062                 :            :                 action_type = action->type;
    1063         [ #  # ]:          0 :                 switch (action_type) {
    1064                 :          0 :                 case RTE_FLOW_ACTION_TYPE_RSS:
    1065                 :          0 :                         rss = action->conf;
    1066                 :          0 :                         rss_type = rss->types;
    1067                 :            : 
    1068                 :            :                         /* Check hash function and save it to rss_meta. */
    1069         [ #  # ]:          0 :                         if (pattern_match_item->pattern_list !=
    1070         [ #  # ]:          0 :                             pattern_empty && rss->func ==
    1071                 :            :                             RTE_ETH_HASH_FUNCTION_SIMPLE_XOR) {
    1072                 :          0 :                                 return rte_flow_error_set(error, ENOTSUP,
    1073                 :            :                                         RTE_FLOW_ERROR_TYPE_ACTION, action,
    1074                 :            :                                         "Not supported flow");
    1075         [ #  # ]:          0 :                         } else if (rss->func ==
    1076                 :            :                                    RTE_ETH_HASH_FUNCTION_SIMPLE_XOR){
    1077                 :          0 :                                 rss_meta->hash_function =
    1078                 :            :                                 RTE_ETH_HASH_FUNCTION_SIMPLE_XOR;
    1079                 :          0 :                                 return 0;
    1080         [ #  # ]:          0 :                         } else if (rss->func ==
    1081                 :            :                                    RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ) {
    1082                 :          0 :                                 rss_meta->hash_function =
    1083                 :            :                                 RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ;
    1084         [ #  # ]:          0 :                                 if (pattern_hint == ICE_PHINT_RAW)
    1085                 :          0 :                                         rss_meta->raw.symm = true;
    1086                 :            :                                 else
    1087                 :          0 :                                         cfg->symm = true;
    1088                 :            :                         }
    1089                 :            : 
    1090         [ #  # ]:          0 :                         if (rss->level)
    1091                 :          0 :                                 return rte_flow_error_set(error, ENOTSUP,
    1092                 :            :                                         RTE_FLOW_ERROR_TYPE_ACTION, action,
    1093                 :            :                                         "a nonzero RSS encapsulation level is not supported");
    1094                 :            : 
    1095         [ #  # ]:          0 :                         if (rss->key_len)
    1096                 :          0 :                                 return rte_flow_error_set(error, ENOTSUP,
    1097                 :            :                                         RTE_FLOW_ERROR_TYPE_ACTION, action,
    1098                 :            :                                         "a nonzero RSS key_len is not supported");
    1099                 :            : 
    1100         [ #  # ]:          0 :                         if (rss->queue)
    1101                 :          0 :                                 return rte_flow_error_set(error, ENOTSUP,
    1102                 :            :                                         RTE_FLOW_ERROR_TYPE_ACTION, action,
    1103                 :            :                                         "a non-NULL RSS queue is not supported");
    1104                 :            : 
    1105                 :            :                         /* If pattern type is raw, no need to refine rss type */
    1106         [ #  # ]:          0 :                         if (pattern_hint == ICE_PHINT_RAW)
    1107                 :            :                                 break;
    1108                 :            : 
    1109                 :            :                         /**
    1110                 :            :                          * Check simultaneous use of SRC_ONLY and DST_ONLY
    1111                 :            :                          * of the same level.
    1112                 :            :                          */
    1113                 :            :                         rss_type = rte_eth_rss_hf_refine(rss_type);
    1114                 :            : 
    1115         [ #  # ]:          0 :                         if (ice_any_invalid_rss_type(rss->func, rss_type,
    1116                 :            :                                         pattern_match_item->input_set_mask_o))
    1117                 :          0 :                                 return rte_flow_error_set(error, ENOTSUP,
    1118                 :            :                                         RTE_FLOW_ERROR_TYPE_ACTION,
    1119                 :            :                                         action, "RSS type not supported");
    1120                 :            : 
    1121                 :          0 :                         rss_meta->cfg = *cfg;
    1122                 :          0 :                         ice_refine_hash_cfg(&rss_meta->cfg,
    1123                 :            :                                             rss_type, pattern_hint);
    1124                 :          0 :                         break;
    1125                 :            :                 case RTE_FLOW_ACTION_TYPE_END:
    1126                 :            :                         break;
    1127                 :            : 
    1128                 :          0 :                 default:
    1129                 :          0 :                         rte_flow_error_set(error, EINVAL,
    1130                 :            :                                         RTE_FLOW_ERROR_TYPE_ACTION, action,
    1131                 :            :                                         "Invalid action.");
    1132                 :          0 :                         return -rte_errno;
    1133                 :            :                 }
    1134                 :            :         }
    1135                 :            : 
    1136                 :            :         return 0;
    1137                 :            : }
    1138                 :            : 
    1139                 :            : static int
    1140                 :          0 : ice_hash_parse_pattern_action(__rte_unused struct ice_adapter *ad,
    1141                 :            :                         struct ice_pattern_match_item *array,
    1142                 :            :                         uint32_t array_len,
    1143                 :            :                         const struct rte_flow_item pattern[],
    1144                 :            :                         const struct rte_flow_action actions[],
    1145                 :            :                         uint32_t priority,
    1146                 :            :                         void **meta,
    1147                 :            :                         struct rte_flow_error *error)
    1148                 :            : {
    1149                 :            :         int ret = 0;
    1150                 :            :         struct ice_pattern_match_item *pattern_match_item;
    1151                 :            :         struct ice_rss_meta *rss_meta_ptr;
    1152                 :          0 :         uint64_t phint = ICE_PHINT_NONE;
    1153                 :            : 
    1154         [ #  # ]:          0 :         if (priority >= 1)
    1155                 :          0 :                 return -rte_errno;
    1156                 :            : 
    1157                 :          0 :         rss_meta_ptr = rte_zmalloc(NULL, sizeof(*rss_meta_ptr), 0);
    1158         [ #  # ]:          0 :         if (!rss_meta_ptr) {
    1159                 :          0 :                 rte_flow_error_set(error, EINVAL,
    1160                 :            :                                 RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
    1161                 :            :                                 "No memory for rss_meta_ptr");
    1162                 :          0 :                 return -ENOMEM;
    1163                 :            :         }
    1164                 :            : 
    1165                 :            :         /* Check rss supported pattern and find matched pattern. */
    1166                 :          0 :         pattern_match_item = ice_search_pattern_match_item(ad, pattern, array,
    1167                 :            :                                                            array_len, error);
    1168         [ #  # ]:          0 :         if (!pattern_match_item) {
    1169                 :          0 :                 ret = -rte_errno;
    1170                 :          0 :                 goto error;
    1171                 :            :         }
    1172                 :            : 
    1173                 :          0 :         ret = ice_hash_parse_pattern(pattern, &phint, error);
    1174         [ #  # ]:          0 :         if (ret)
    1175                 :          0 :                 goto error;
    1176                 :            : 
    1177         [ #  # ]:          0 :         if (phint == ICE_PHINT_RAW) {
    1178                 :          0 :                 rss_meta_ptr->raw.raw_ena = true;
    1179                 :          0 :                 ret = ice_hash_parse_raw_pattern(ad, pattern, rss_meta_ptr);
    1180         [ #  # ]:          0 :                 if (ret) {
    1181                 :          0 :                         rte_flow_error_set(error, EINVAL,
    1182                 :            :                                            RTE_FLOW_ERROR_TYPE_ITEM, NULL,
    1183                 :            :                                            "Parse raw pattern failed");
    1184                 :          0 :                         goto error;
    1185                 :            :                 }
    1186                 :            :         }
    1187                 :            : 
    1188                 :            :         /* Check rss action. */
    1189                 :          0 :         ret = ice_hash_parse_action(pattern_match_item, actions, phint,
    1190                 :            :                                     rss_meta_ptr, error);
    1191                 :            : 
    1192                 :          0 : error:
    1193         [ #  # ]:          0 :         if (!ret && meta)
    1194                 :          0 :                 *meta = rss_meta_ptr;
    1195                 :            :         else
    1196                 :          0 :                 rte_free(rss_meta_ptr);
    1197                 :          0 :         rte_free(pattern_match_item);
    1198                 :            : 
    1199                 :          0 :         return ret;
    1200                 :            : }
    1201                 :            : 
    1202                 :            : static int
    1203                 :          0 : ice_hash_add_raw_cfg(struct ice_adapter *ad,
    1204                 :            :                 struct ice_rss_raw_cfg *cfg, u16 vsi_handle)
    1205                 :            : {
    1206                 :          0 :         struct ice_parser_profile *prof = &cfg->prof;
    1207                 :            :         struct ice_rss_prof_info *rss_prof;
    1208                 :          0 :         struct ice_hw *hw = &ad->hw;
    1209                 :            :         int i, ptg, ret;
    1210                 :            :         u64 id;
    1211                 :            : 
    1212                 :          0 :         id = (u64)ice_find_first_bit(prof->ptypes, UINT16_MAX);
    1213                 :            : 
    1214                 :          0 :         ptg = hw->blk[ICE_BLK_RSS].xlt1.t[id];
    1215                 :            :         rss_prof = &ad->rss_prof_info[ptg];
    1216                 :            :         /* check if ptg already has profile */
    1217         [ #  # ]:          0 :         if (rss_prof->prof.fv_num) {
    1218         [ #  # ]:          0 :                 for (i = 0; i < ICE_MAX_FV_WORDS; i++) {
    1219                 :          0 :                         if (rss_prof->prof.fv[i].proto_id !=
    1220         [ #  # ]:          0 :                             prof->fv[i].proto_id ||
    1221                 :          0 :                             rss_prof->prof.fv[i].offset !=
    1222         [ #  # ]:          0 :                             prof->fv[i].offset)
    1223                 :            :                                 break;
    1224                 :            :                 }
    1225                 :            : 
    1226                 :            :                 /* current profile is matched, check symmetric hash */
    1227         [ #  # ]:          0 :                 if (i == ICE_MAX_FV_WORDS) {
    1228         [ #  # ]:          0 :                         if (rss_prof->symm != cfg->symm)
    1229                 :          0 :                                 goto update_symm;
    1230                 :            : 
    1231                 :            :                         return 0;
    1232                 :            :                 }
    1233                 :            : 
    1234                 :            :                 /* current profile is not matched, remove it */
    1235                 :          0 :                 ret = ice_rem_prof_id_flow(hw, ICE_BLK_RSS,
    1236                 :          0 :                                            ice_get_hw_vsi_num(hw, vsi_handle),
    1237                 :            :                                            id);
    1238         [ #  # ]:          0 :                 if (ret) {
    1239                 :          0 :                         PMD_DRV_LOG(ERR, "remove RSS flow failed\n");
    1240                 :          0 :                         return ret;
    1241                 :            :                 }
    1242                 :            : 
    1243                 :          0 :                 ret = ice_rem_prof(hw, ICE_BLK_RSS, id);
    1244         [ #  # ]:          0 :                 if (ret) {
    1245                 :          0 :                         PMD_DRV_LOG(ERR, "remove RSS profile failed\n");
    1246                 :          0 :                         return ret;
    1247                 :            :                 }
    1248                 :            :         }
    1249                 :            : 
    1250                 :            :         /* add new profile */
    1251                 :          0 :         ret = ice_flow_set_hw_prof(hw, vsi_handle, 0, prof, ICE_BLK_RSS);
    1252         [ #  # ]:          0 :         if (ret) {
    1253                 :          0 :                 PMD_DRV_LOG(ERR, "HW profile add failed\n");
    1254                 :          0 :                 return ret;
    1255                 :            :         }
    1256                 :            : 
    1257                 :          0 :         rss_prof->symm = cfg->symm;
    1258         [ #  # ]:          0 :         ice_memcpy(&rss_prof->prof, prof,
    1259                 :            :                    sizeof(struct ice_parser_profile),
    1260                 :            :                    ICE_NONDMA_TO_NONDMA);
    1261                 :            : 
    1262                 :          0 : update_symm:
    1263                 :          0 :         ice_rss_update_raw_symm(hw, cfg, id);
    1264                 :          0 :         return 0;
    1265                 :            : }
    1266                 :            : 
    1267                 :            : static int
    1268                 :          0 : ice_hash_create(struct ice_adapter *ad,
    1269                 :            :                 struct rte_flow *flow,
    1270                 :            :                 void *meta,
    1271                 :            :                 struct rte_flow_error *error)
    1272                 :            : {
    1273                 :          0 :         struct ice_pf *pf = &ad->pf;
    1274                 :          0 :         struct ice_hw *hw = ICE_PF_TO_HW(pf);
    1275                 :          0 :         struct ice_vsi *vsi = pf->main_vsi;
    1276                 :            :         int ret;
    1277                 :            :         uint32_t reg;
    1278                 :            :         struct ice_hash_flow_cfg *filter_ptr;
    1279                 :            :         struct ice_rss_meta *rss_meta = (struct ice_rss_meta *)meta;
    1280                 :          0 :         uint8_t hash_function = rss_meta->hash_function;
    1281                 :            : 
    1282                 :          0 :         filter_ptr = rte_zmalloc("ice_rss_filter",
    1283                 :            :                                 sizeof(struct ice_hash_flow_cfg), 0);
    1284         [ #  # ]:          0 :         if (!filter_ptr) {
    1285                 :          0 :                 rte_flow_error_set(error, EINVAL,
    1286                 :            :                                 RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
    1287                 :            :                                 "No memory for filter_ptr");
    1288                 :          0 :                 return -ENOMEM;
    1289                 :            :         }
    1290                 :            : 
    1291         [ #  # ]:          0 :         if (hash_function == RTE_ETH_HASH_FUNCTION_SIMPLE_XOR) {
    1292                 :            :                 /* Enable registers for simple_xor hash function. */
    1293                 :          0 :                 reg = ICE_READ_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id));
    1294                 :          0 :                 reg = (reg & (~VSIQF_HASH_CTL_HASH_SCHEME_M)) |
    1295                 :            :                         (2 << VSIQF_HASH_CTL_HASH_SCHEME_S);
    1296                 :          0 :                 ICE_WRITE_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id), reg);
    1297                 :            : 
    1298                 :          0 :                 filter_ptr->simple_xor = 1;
    1299                 :            : 
    1300                 :          0 :                 goto out;
    1301                 :            :         } else {
    1302         [ #  # ]:          0 :                 if (rss_meta->raw.raw_ena) {
    1303                 :          0 :                         memcpy(&filter_ptr->rss_cfg.raw, &rss_meta->raw,
    1304                 :            :                                sizeof(struct ice_rss_raw_cfg));
    1305                 :          0 :                         ret = ice_hash_add_raw_cfg(ad, &rss_meta->raw,
    1306                 :          0 :                                                    pf->main_vsi->idx);
    1307         [ #  # ]:          0 :                         if (ret) {
    1308                 :          0 :                                 rte_flow_error_set(error, EINVAL,
    1309                 :            :                                                    RTE_FLOW_ERROR_TYPE_HANDLE,
    1310                 :            :                                                    NULL,
    1311                 :            :                                                    "rss flow create fail");
    1312                 :          0 :                                 goto error;
    1313                 :            :                         }
    1314                 :            :                 } else {
    1315                 :          0 :                         memcpy(&filter_ptr->rss_cfg.hash, &rss_meta->cfg,
    1316                 :            :                                sizeof(struct ice_rss_hash_cfg));
    1317                 :          0 :                         ret = ice_add_rss_cfg_wrap(pf, vsi->idx,
    1318                 :            :                                                    &filter_ptr->rss_cfg.hash);
    1319         [ #  # ]:          0 :                         if (ret) {
    1320                 :          0 :                                 rte_flow_error_set(error, EINVAL,
    1321                 :            :                                                    RTE_FLOW_ERROR_TYPE_HANDLE,
    1322                 :            :                                                    NULL,
    1323                 :            :                                                    "rss flow create fail");
    1324                 :          0 :                                 goto error;
    1325                 :            :                         }
    1326                 :            :                 }
    1327                 :            :         }
    1328                 :            : 
    1329                 :          0 : out:
    1330                 :          0 :         flow->rule = filter_ptr;
    1331                 :          0 :         rte_free(meta);
    1332                 :          0 :         return 0;
    1333                 :            : 
    1334                 :          0 : error:
    1335                 :          0 :         rte_free(filter_ptr);
    1336                 :          0 :         rte_free(meta);
    1337                 :          0 :         return -rte_errno;
    1338                 :            : }
    1339                 :            : 
    1340                 :            : static int
    1341                 :          0 : ice_hash_rem_raw_cfg(struct ice_adapter *ad,
    1342                 :            :                         struct ice_parser_profile *prof,
    1343                 :            :                     u16 vsi_handle)
    1344                 :            : {
    1345                 :          0 :         struct ice_hw *hw = &ad->hw;
    1346                 :            :         int ptg, ret;
    1347                 :            :         u16 vsig;
    1348                 :            :         u64 id;
    1349                 :            : 
    1350                 :          0 :         id = (u64)ice_find_first_bit(prof->ptypes, 0xFFFF);
    1351                 :            : 
    1352                 :          0 :         ptg = hw->blk[ICE_BLK_RSS].xlt1.t[id];
    1353                 :            : 
    1354                 :          0 :         memset(&ad->rss_prof_info[ptg], 0,
    1355                 :            :                 sizeof(struct ice_rss_prof_info));
    1356                 :            : 
    1357                 :            :         /* check if vsig is already removed */
    1358                 :          0 :         ret = ice_vsig_find_vsi(hw, ICE_BLK_RSS,
    1359                 :          0 :                 ice_get_hw_vsi_num(hw, vsi_handle), &vsig);
    1360   [ #  #  #  # ]:          0 :         if (!ret && vsig) {
    1361                 :          0 :                 ret = ice_rem_prof_id_flow(hw, ICE_BLK_RSS,
    1362                 :          0 :                                            ice_get_hw_vsi_num(hw, vsi_handle),
    1363                 :            :                                            id);
    1364         [ #  # ]:          0 :                 if (ret)
    1365                 :          0 :                         goto err;
    1366                 :            : 
    1367                 :          0 :                 ret = ice_rem_prof(hw, ICE_BLK_RSS, id);
    1368         [ #  # ]:          0 :                 if (ret)
    1369                 :          0 :                         goto err;
    1370                 :            :         }
    1371                 :            : 
    1372                 :            :         return 0;
    1373                 :            : 
    1374                 :          0 : err:
    1375                 :          0 :         PMD_DRV_LOG(ERR, "HW profile remove failed\n");
    1376                 :          0 :         return ret;
    1377                 :            : }
    1378                 :            : 
    1379                 :            : static int
    1380                 :          0 : ice_hash_destroy(struct ice_adapter *ad,
    1381                 :            :                 struct rte_flow *flow,
    1382                 :            :                 struct rte_flow_error *error)
    1383                 :            : {
    1384                 :          0 :         struct ice_pf *pf = ICE_DEV_PRIVATE_TO_PF(ad);
    1385                 :          0 :         struct ice_hw *hw = ICE_PF_TO_HW(pf);
    1386                 :          0 :         struct ice_vsi *vsi = pf->main_vsi;
    1387                 :            :         int ret;
    1388                 :            :         uint32_t reg;
    1389                 :            :         struct ice_hash_flow_cfg *filter_ptr;
    1390                 :            : 
    1391                 :          0 :         filter_ptr = (struct ice_hash_flow_cfg *)flow->rule;
    1392                 :            : 
    1393         [ #  # ]:          0 :         if (filter_ptr->simple_xor == 1) {
    1394                 :            :                 /* Return to symmetric_toeplitz state. */
    1395                 :          0 :                 reg = ICE_READ_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id));
    1396                 :          0 :                 reg = (reg & (~VSIQF_HASH_CTL_HASH_SCHEME_M)) |
    1397                 :            :                         (1 << VSIQF_HASH_CTL_HASH_SCHEME_S);
    1398                 :          0 :                 ICE_WRITE_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id), reg);
    1399                 :            :         } else {
    1400         [ #  # ]:          0 :                 if (filter_ptr->rss_cfg.raw.raw_ena) {
    1401                 :            :                         ret =
    1402                 :          0 :                         ice_hash_rem_raw_cfg(ad, &filter_ptr->rss_cfg.raw.prof,
    1403                 :          0 :                                              pf->main_vsi->idx);
    1404         [ #  # ]:          0 :                         if (ret) {
    1405                 :          0 :                                 rte_flow_error_set(error, EINVAL,
    1406                 :            :                                                    RTE_FLOW_ERROR_TYPE_HANDLE,
    1407                 :            :                                                    NULL,
    1408                 :            :                                                    "rss flow destroy fail");
    1409                 :          0 :                                 goto error;
    1410                 :            :                         }
    1411                 :            :                 } else {
    1412                 :          0 :                         ret = ice_rem_rss_cfg_wrap(pf, vsi->idx,
    1413                 :            :                                                    &filter_ptr->rss_cfg.hash);
    1414                 :            :                         /* Fixme: Ignore the error if a rule does not exist.
    1415                 :            :                          * Currently a rule for inputset change or symm turn
    1416                 :            :                          * on/off will overwrite an exist rule, while
    1417                 :            :                          * application still have 2 rte_flow handles.
    1418                 :            :                          **/
    1419         [ #  # ]:          0 :                         if (ret && ret != ICE_ERR_DOES_NOT_EXIST) {
    1420                 :          0 :                                 rte_flow_error_set(error, EINVAL,
    1421                 :            :                                                    RTE_FLOW_ERROR_TYPE_HANDLE,
    1422                 :            :                                                    NULL,
    1423                 :            :                                                    "rss flow destroy fail");
    1424                 :          0 :                                 goto error;
    1425                 :            :                         }
    1426                 :            :                 }
    1427                 :            :         }
    1428                 :            : 
    1429                 :          0 :         rte_free(filter_ptr);
    1430                 :          0 :         return 0;
    1431                 :            : 
    1432                 :          0 : error:
    1433                 :          0 :         rte_free(filter_ptr);
    1434                 :          0 :         return -rte_errno;
    1435                 :            : }
    1436                 :            : 
    1437                 :            : static void
    1438                 :          0 : ice_hash_uninit(struct ice_adapter *ad __rte_unused)
    1439                 :            : {
    1440                 :          0 : }
    1441                 :            : 
    1442                 :            : static void
    1443                 :          0 : ice_hash_free(struct rte_flow *flow)
    1444                 :            : {
    1445                 :          0 :         rte_free(flow->rule);
    1446                 :          0 : }

Generated by: LCOV version 1.14