drivers/net/ice/base/ice_flow.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2001-2019
   3  */
   4
   5 #include "ice_common.h"
   6 #include "ice_flow.h"
   7
   8 /* Size of known protocol header fields */
   9 #define ICE_FLOW_FLD_SZ_ETH_TYPE        2
  10 #define ICE_FLOW_FLD_SZ_VLAN            2
  11 #define ICE_FLOW_FLD_SZ_IPV4_ADDR       4
  12 #define ICE_FLOW_FLD_SZ_IPV6_ADDR       16
  13 #define ICE_FLOW_FLD_SZ_IP_DSCP         1
  14 #define ICE_FLOW_FLD_SZ_IP_TTL          1
  15 #define ICE_FLOW_FLD_SZ_IP_PROT         1
  16 #define ICE_FLOW_FLD_SZ_PORT            2
  17 #define ICE_FLOW_FLD_SZ_TCP_FLAGS       1
  18 #define ICE_FLOW_FLD_SZ_ICMP_TYPE       1
  19 #define ICE_FLOW_FLD_SZ_ICMP_CODE       1
  20 #define ICE_FLOW_FLD_SZ_ARP_OPER        2
  21 #define ICE_FLOW_FLD_SZ_GRE_KEYID       4
  22
  23 /* Protocol header fields are extracted at the word boundaries as word-sized
  24  * values. Specify the displacement value of some non-word-aligned fields needed
  25  * to compute the offset of words containing the fields in the corresponding
  26  * protocol headers. Displacement values are expressed in number of bits.
  27  */
  28 #define ICE_FLOW_FLD_IPV6_TTL_DSCP_DISP (-4)
  29 #define ICE_FLOW_FLD_IPV6_TTL_PROT_DISP ((-2) * BITS_PER_BYTE)
  30 #define ICE_FLOW_FLD_IPV6_TTL_TTL_DISP  ((-1) * BITS_PER_BYTE)
  31
  32 /* Describe properties of a protocol header field */
  33 struct ice_flow_field_info {
  34         enum ice_flow_seg_hdr hdr;
  35         s16 off;        /* Offset from start of a protocol header, in bits */
  36         u16 size;       /* Size of fields in bits */
  37 };
  38
  39 #define ICE_FLOW_FLD_INFO(_hdr, _offset_bytes, _size_bytes) { \
  40         .hdr = _hdr, \
  41         .off = _offset_bytes * BITS_PER_BYTE, \
  42         .size = _size_bytes * BITS_PER_BYTE, \
  43 }
  44
  45 /* Table containing properties of supported protocol header fields */
  46 static const
  47 struct ice_flow_field_info ice_flds_info[ICE_FLOW_FIELD_IDX_MAX] = {
  48         /* Ether */
  49         /* ICE_FLOW_FIELD_IDX_ETH_DA */
  50         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_ETH, 0, ETH_ALEN),
  51         /* ICE_FLOW_FIELD_IDX_ETH_SA */
  52         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_ETH, ETH_ALEN, ETH_ALEN),
  53         /* ICE_FLOW_FIELD_IDX_S_VLAN */
  54         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_VLAN, 12, ICE_FLOW_FLD_SZ_VLAN),
  55         /* ICE_FLOW_FIELD_IDX_C_VLAN */
  56         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_VLAN, 14, ICE_FLOW_FLD_SZ_VLAN),
  57         /* ICE_FLOW_FIELD_IDX_ETH_TYPE */
  58         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_ETH, 12, ICE_FLOW_FLD_SZ_ETH_TYPE),
  59         /* IPv4 */
  60         /* ICE_FLOW_FIELD_IDX_IP_DSCP */
  61         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_IPV4, 1, 1),
  62         /* ICE_FLOW_FIELD_IDX_IP_TTL */
  63         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_NONE, 8, 1),
  64         /* ICE_FLOW_FIELD_IDX_IP_PROT */
  65         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_NONE, 9, ICE_FLOW_FLD_SZ_IP_PROT),
  66         /* ICE_FLOW_FIELD_IDX_IPV4_SA */
  67         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_IPV4, 12, ICE_FLOW_FLD_SZ_IPV4_ADDR),
  68         /* ICE_FLOW_FIELD_IDX_IPV4_DA */
  69         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_IPV4, 16, ICE_FLOW_FLD_SZ_IPV4_ADDR),
  70         /* IPv6 */
  71         /* ICE_FLOW_FIELD_IDX_IPV6_SA */
  72         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_IPV6, 8, ICE_FLOW_FLD_SZ_IPV6_ADDR),
  73         /* ICE_FLOW_FIELD_IDX_IPV6_DA */
  74         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_IPV6, 24, ICE_FLOW_FLD_SZ_IPV6_ADDR),
  75         /* Transport */
  76         /* ICE_FLOW_FIELD_IDX_TCP_SRC_PORT */
  77         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_TCP, 0, ICE_FLOW_FLD_SZ_PORT),
  78         /* ICE_FLOW_FIELD_IDX_TCP_DST_PORT */
  79         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_TCP, 2, ICE_FLOW_FLD_SZ_PORT),
  80         /* ICE_FLOW_FIELD_IDX_UDP_SRC_PORT */
  81         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_UDP, 0, ICE_FLOW_FLD_SZ_PORT),
  82         /* ICE_FLOW_FIELD_IDX_UDP_DST_PORT */
  83         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_UDP, 2, ICE_FLOW_FLD_SZ_PORT),
  84         /* ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT */
  85         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_SCTP, 0, ICE_FLOW_FLD_SZ_PORT),
  86         /* ICE_FLOW_FIELD_IDX_SCTP_DST_PORT */
  87         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_SCTP, 2, ICE_FLOW_FLD_SZ_PORT),
  88         /* ICE_FLOW_FIELD_IDX_TCP_FLAGS */
  89         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_TCP, 13, ICE_FLOW_FLD_SZ_TCP_FLAGS),
  90         /* ARP */
  91         /* ICE_FLOW_FIELD_IDX_ARP_SIP */
  92         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_ARP, 14, ICE_FLOW_FLD_SZ_IPV4_ADDR),
  93         /* ICE_FLOW_FIELD_IDX_ARP_DIP */
  94         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_ARP, 24, ICE_FLOW_FLD_SZ_IPV4_ADDR),
  95         /* ICE_FLOW_FIELD_IDX_ARP_SHA */
  96         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_ARP, 8, ETH_ALEN),
  97         /* ICE_FLOW_FIELD_IDX_ARP_DHA */
  98         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_ARP, 18, ETH_ALEN),
  99         /* ICE_FLOW_FIELD_IDX_ARP_OP */
 100         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_ARP, 6, ICE_FLOW_FLD_SZ_ARP_OPER),
 101         /* ICMP */
 102         /* ICE_FLOW_FIELD_IDX_ICMP_TYPE */
 103         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_ICMP, 0, ICE_FLOW_FLD_SZ_ICMP_TYPE),
 104         /* ICE_FLOW_FIELD_IDX_ICMP_CODE */
 105         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_ICMP, 1, ICE_FLOW_FLD_SZ_ICMP_CODE),
 106         /* GRE */
 107         /* ICE_FLOW_FIELD_IDX_GRE_KEYID */
 108         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_GRE, 12, ICE_FLOW_FLD_SZ_GRE_KEYID),
 109 };
 110
 111 /* Bitmaps indicating relevant packet types for a particular protocol header
 112  *
 113  * Packet types for packets with an Outer/First/Single MAC header
 114  */
 115 static const u32 ice_ptypes_mac_ofos[] = {
 116         0xFDC00CC6, 0xBFBF7F7E, 0xF7EFDFDF, 0xFEFDFDFB,
 117         0x03BF7F7E, 0x00000000, 0x00000000, 0x00000000,
 118         0x000B0F0F, 0x00000000, 0x00000000, 0x00000000,
 119         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 120         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 121         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 122         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 123         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 124 };
 125
 126 /* Packet types for packets with an Innermost/Last MAC VLAN header */
 127 static const u32 ice_ptypes_macvlan_il[] = {
 128         0x00000000, 0xBC000000, 0x000001DF, 0xF0000000,
 129         0x0000077E, 0x00000000, 0x00000000, 0x00000000,
 130         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 131         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 132         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 133         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 134         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 135         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 136 };
 137
 138 /* Packet types for packets with an Outer/First/Single IPv4 header */
 139 static const u32 ice_ptypes_ipv4_ofos[] = {
 140         0xFDC00000, 0xBFBF7F7E, 0x00EFDFDF, 0x00000000,
 141         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 142         0x0003000F, 0x00000000, 0x00000000, 0x00000000,
 143         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 144         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 145         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 146         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 147         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 148 };
 149
 150 /* Packet types for packets with an Innermost/Last IPv4 header */
 151 static const u32 ice_ptypes_ipv4_il[] = {
 152         0xE0000000, 0xB807700E, 0x8001DC03, 0xE01DC03B,
 153         0x0007700E, 0x00000000, 0x00000000, 0x00000000,
 154         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 155         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 156         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 157         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 158         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 159         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 160 };
 161
 162 /* Packet types for packets with an Outer/First/Single IPv6 header */
 163 static const u32 ice_ptypes_ipv6_ofos[] = {
 164         0x00000000, 0x00000000, 0xF7000000, 0xFEFDFDFB,
 165         0x03BF7F7E, 0x00000000, 0x00000000, 0x00000000,
 166         0x00080F00, 0x00000000, 0x00000000, 0x00000000,
 167         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 168         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 169         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 170         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 171         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 172 };
 173
 174 /* Packet types for packets with an Innermost/Last IPv6 header */
 175 static const u32 ice_ptypes_ipv6_il[] = {
 176         0x00000000, 0x03B80770, 0x00EE01DC, 0x0EE00000,
 177         0x03B80770, 0x00000000, 0x00000000, 0x00000000,
 178         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 179         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 180         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 181         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 182         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 183         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 184 };
 185
 186 /* Packet types for packets with an Outermost/First ARP header */
 187 static const u32 ice_ptypes_arp_of[] = {
 188         0x00000800, 0x00000000, 0x00000000, 0x00000000,
 189         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 190         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 191         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 192         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 193         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 194         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 195         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 196 };
 197
 198 /* UDP Packet types for non-tunneled packets or tunneled
 199  * packets with inner UDP.
 200  */
 201 static const u32 ice_ptypes_udp_il[] = {
 202         0x81000000, 0x20204040, 0x04081010, 0x80810102,
 203         0x00204040, 0x00000000, 0x00000000, 0x00000000,
 204         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 205         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 206         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 207         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 208         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 209         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 210 };
 211
 212 /* Packet types for packets with an Innermost/Last TCP header */
 213 static const u32 ice_ptypes_tcp_il[] = {
 214         0x04000000, 0x80810102, 0x10204040, 0x42040408,
 215         0x00810102, 0x00000000, 0x00000000, 0x00000000,
 216         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 217         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 218         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 219         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 220         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 221         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 222 };
 223
 224 /* Packet types for packets with an Innermost/Last SCTP header */
 225 static const u32 ice_ptypes_sctp_il[] = {
 226         0x08000000, 0x01020204, 0x20408081, 0x04080810,
 227         0x01020204, 0x00000000, 0x00000000, 0x00000000,
 228         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 229         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 230         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 231         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 232         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 233         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 234 };
 235
 236 /* Packet types for packets with an Outermost/First ICMP header */
 237 static const u32 ice_ptypes_icmp_of[] = {
 238         0x10000000, 0x00000000, 0x00000000, 0x00000000,
 239         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 240         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 241         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 242         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 243         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 244         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 245         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 246 };
 247
 248 /* Packet types for packets with an Innermost/Last ICMP header */
 249 static const u32 ice_ptypes_icmp_il[] = {
 250         0x00000000, 0x02040408, 0x40810102, 0x08101020,
 251         0x02040408, 0x00000000, 0x00000000, 0x00000000,
 252         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 253         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 254         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 255         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 256         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 257         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 258 };
 259
 260 /* Packet types for packets with an Outermost/First GRE header */
 261 static const u32 ice_ptypes_gre_of[] = {
 262         0x00000000, 0xBFBF7800, 0x00EFDFDF, 0xFEFDE000,
 263         0x03BF7F7E, 0x00000000, 0x00000000, 0x00000000,
 264         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 265         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 266         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 267         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 268         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 269         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 270 };
 271
 272 /* Packet types for packets with an Innermost/Last MAC header */
 273 static const u32 ice_ptypes_mac_il[] = {
 274         0x00000000, 0x00000000, 0x00EFDE00, 0x00000000,
 275         0x03BF7800, 0x00000000, 0x00000000, 0x00000000,
 276         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 277         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 278         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 279         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 280         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 281         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 282 };
 283
 284 /* Manage parameters and info. used during the creation of a flow profile */
 285 struct ice_flow_prof_params {
 286         enum ice_block blk;
 287         u16 entry_length; /* # of bytes formatted entry will require */
 288         u8 es_cnt;
 289         struct ice_flow_prof *prof;
 290
 291         /* For ACL, the es[0] will have the data of ICE_RX_MDID_PKT_FLAGS_15_0
 292          * This will give us the direction flags.
 293          */
 294         struct ice_fv_word es[ICE_MAX_FV_WORDS];
 295
 296         ice_declare_bitmap(ptypes, ICE_FLOW_PTYPE_MAX);
 297 };
 298
 299 /**
 300  * ice_is_pow2 - check if integer value is a power of 2
 301  * @val: unsigned integer to be validated
 302  */
 303 static bool ice_is_pow2(u64 val)
 304 {
 305         return (val && !(val & (val - 1)));
 306 }
 307
 308 #define ICE_FLOW_SEG_HDRS_L2_MASK       \
 309         (ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_VLAN)
 310 #define ICE_FLOW_SEG_HDRS_L3_MASK       \
 311         (ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_ARP)
 312 #define ICE_FLOW_SEG_HDRS_L4_MASK       \
 313         (ICE_FLOW_SEG_HDR_ICMP | ICE_FLOW_SEG_HDR_TCP | ICE_FLOW_SEG_HDR_UDP | \
 314          ICE_FLOW_SEG_HDR_SCTP)
 315
 316 /**
 317  * ice_flow_val_hdrs - validates packet segments for valid protocol headers
 318  * @segs: array of one or more packet segments that describe the flow
 319  * @segs_cnt: number of packet segments provided
 320  */
 321 static enum ice_status
 322 ice_flow_val_hdrs(struct ice_flow_seg_info *segs, u8 segs_cnt)
 323 {
 324         const u32 masks = (ICE_FLOW_SEG_HDRS_L2_MASK |
 325                            ICE_FLOW_SEG_HDRS_L3_MASK |
 326                            ICE_FLOW_SEG_HDRS_L4_MASK);
 327         u8 i;
 328
 329         for (i = 0; i < segs_cnt; i++) {
 330                 /* No header specified */
 331                 if (!(segs[i].hdrs & masks) || (segs[i].hdrs & ~masks))
 332                         return ICE_ERR_PARAM;
 333
 334                 /* Multiple L3 headers */
 335                 if (segs[i].hdrs & ICE_FLOW_SEG_HDRS_L3_MASK &&
 336                     !ice_is_pow2(segs[i].hdrs & ICE_FLOW_SEG_HDRS_L3_MASK))
 337                         return ICE_ERR_PARAM;
 338
 339                 /* Multiple L4 headers */
 340                 if (segs[i].hdrs & ICE_FLOW_SEG_HDRS_L4_MASK &&
 341                     !ice_is_pow2(segs[i].hdrs & ICE_FLOW_SEG_HDRS_L4_MASK))
 342                         return ICE_ERR_PARAM;
 343         }
 344
 345         return ICE_SUCCESS;
 346 }
 347
 348 /* Sizes of fixed known protocol headers without header options */
 349 #define ICE_FLOW_PROT_HDR_SZ_MAC        14
 350 #define ICE_FLOW_PROT_HDR_SZ_MAC_VLAN   (ICE_FLOW_PROT_HDR_SZ_MAC + 2)
 351 #define ICE_FLOW_PROT_HDR_SZ_IPV4       20
 352 #define ICE_FLOW_PROT_HDR_SZ_IPV6       40
 353 #define ICE_FLOW_PROT_HDR_SZ_ARP        28
 354 #define ICE_FLOW_PROT_HDR_SZ_ICMP       8
 355 #define ICE_FLOW_PROT_HDR_SZ_TCP        20
 356 #define ICE_FLOW_PROT_HDR_SZ_UDP        8
 357 #define ICE_FLOW_PROT_HDR_SZ_SCTP       12
 358
 359 /**
 360  * ice_flow_calc_seg_sz - calculates size of a packet segment based on headers
 361  * @params: information about the flow to be processed
 362  * @seg: index of packet segment whose header size is to be determined
 363  */
 364 static u16 ice_flow_calc_seg_sz(struct ice_flow_prof_params *params, u8 seg)
 365 {
 366         u16 sz;
 367
 368         /* L2 headers */
 369         sz = (params->prof->segs[seg].hdrs & ICE_FLOW_SEG_HDR_VLAN) ?
 370                 ICE_FLOW_PROT_HDR_SZ_MAC_VLAN : ICE_FLOW_PROT_HDR_SZ_MAC;
 371
 372         /* L3 headers */
 373         if (params->prof->segs[seg].hdrs & ICE_FLOW_SEG_HDR_IPV4)
 374                 sz += ICE_FLOW_PROT_HDR_SZ_IPV4;
 375         else if (params->prof->segs[seg].hdrs & ICE_FLOW_SEG_HDR_IPV6)
 376                 sz += ICE_FLOW_PROT_HDR_SZ_IPV6;
 377         else if (params->prof->segs[seg].hdrs & ICE_FLOW_SEG_HDR_ARP)
 378                 sz += ICE_FLOW_PROT_HDR_SZ_ARP;
 379         else if (params->prof->segs[seg].hdrs & ICE_FLOW_SEG_HDRS_L4_MASK)
 380                 /* A L3 header is required if L4 is specified */
 381                 return 0;
 382
 383         /* L4 headers */
 384         if (params->prof->segs[seg].hdrs & ICE_FLOW_SEG_HDR_ICMP)
 385                 sz += ICE_FLOW_PROT_HDR_SZ_ICMP;
 386         else if (params->prof->segs[seg].hdrs & ICE_FLOW_SEG_HDR_TCP)
 387                 sz += ICE_FLOW_PROT_HDR_SZ_TCP;
 388         else if (params->prof->segs[seg].hdrs & ICE_FLOW_SEG_HDR_UDP)
 389                 sz += ICE_FLOW_PROT_HDR_SZ_UDP;
 390         else if (params->prof->segs[seg].hdrs & ICE_FLOW_SEG_HDR_SCTP)
 391                 sz += ICE_FLOW_PROT_HDR_SZ_SCTP;
 392
 393         return sz;
 394 }
 395
 396 /**
 397  * ice_flow_proc_seg_hdrs - process protocol headers present in pkt segments
 398  * @params: information about the flow to be processed
 399  *
 400  * This function identifies the packet types associated with the protocol
 401  * headers being present in packet segments of the specified flow profile.
 402  */
 403 static enum ice_status
 404 ice_flow_proc_seg_hdrs(struct ice_flow_prof_params *params)
 405 {
 406         struct ice_flow_prof *prof;
 407         u8 i;
 408
 409         ice_memset(params->ptypes, 0xff, sizeof(params->ptypes),
 410                    ICE_NONDMA_MEM);
 411
 412         prof = params->prof;
 413
 414         for (i = 0; i < params->prof->segs_cnt; i++) {
 415                 const ice_bitmap_t *src;
 416                 u32 hdrs;
 417
 418                 hdrs = prof->segs[i].hdrs;
 419
 420                 if (hdrs & ICE_FLOW_SEG_HDR_ETH) {
 421                         src = !i ? (const ice_bitmap_t *)ice_ptypes_mac_ofos :
 422                                 (const ice_bitmap_t *)ice_ptypes_mac_il;
 423                         ice_and_bitmap(params->ptypes, params->ptypes, src,
 424                                        ICE_FLOW_PTYPE_MAX);
 425                         hdrs &= ~ICE_FLOW_SEG_HDR_ETH;
 426                 }
 427
 428                 if (i && hdrs & ICE_FLOW_SEG_HDR_VLAN) {
 429                         src = (const ice_bitmap_t *)ice_ptypes_macvlan_il;
 430                         ice_and_bitmap(params->ptypes, params->ptypes, src,
 431                                        ICE_FLOW_PTYPE_MAX);
 432                         hdrs &= ~ICE_FLOW_SEG_HDR_VLAN;
 433                 }
 434
 435                 if (!i && hdrs & ICE_FLOW_SEG_HDR_ARP) {
 436                         ice_and_bitmap(params->ptypes, params->ptypes,
 437                                        (const ice_bitmap_t *)ice_ptypes_arp_of,
 438                                        ICE_FLOW_PTYPE_MAX);
 439                         hdrs &= ~ICE_FLOW_SEG_HDR_ARP;
 440                 }
 441
 442                 if (hdrs & ICE_FLOW_SEG_HDR_IPV4) {
 443                         src = !i ? (const ice_bitmap_t *)ice_ptypes_ipv4_ofos :
 444                                 (const ice_bitmap_t *)ice_ptypes_ipv4_il;
 445                         ice_and_bitmap(params->ptypes, params->ptypes, src,
 446                                        ICE_FLOW_PTYPE_MAX);
 447                         hdrs &= ~ICE_FLOW_SEG_HDR_IPV4;
 448                 } else if (hdrs & ICE_FLOW_SEG_HDR_IPV6) {
 449                         src = !i ? (const ice_bitmap_t *)ice_ptypes_ipv6_ofos :
 450                                 (const ice_bitmap_t *)ice_ptypes_ipv6_il;
 451                         ice_and_bitmap(params->ptypes, params->ptypes, src,
 452                                        ICE_FLOW_PTYPE_MAX);
 453                         hdrs &= ~ICE_FLOW_SEG_HDR_IPV6;
 454                 }
 455
 456                 if (hdrs & ICE_FLOW_SEG_HDR_ICMP) {
 457                         src = !i ? (const ice_bitmap_t *)ice_ptypes_icmp_of :
 458                                 (const ice_bitmap_t *)ice_ptypes_icmp_il;
 459                         ice_and_bitmap(params->ptypes, params->ptypes, src,
 460                                        ICE_FLOW_PTYPE_MAX);
 461                         hdrs &= ~ICE_FLOW_SEG_HDR_ICMP;
 462                 } else if (hdrs & ICE_FLOW_SEG_HDR_UDP) {
 463                         src = (const ice_bitmap_t *)ice_ptypes_udp_il;
 464                         ice_and_bitmap(params->ptypes, params->ptypes, src,
 465                                        ICE_FLOW_PTYPE_MAX);
 466                         hdrs &= ~ICE_FLOW_SEG_HDR_UDP;
 467                 } else if (hdrs & ICE_FLOW_SEG_HDR_TCP) {
 468                         ice_and_bitmap(params->ptypes, params->ptypes,
 469                                        (const ice_bitmap_t *)ice_ptypes_tcp_il,
 470                                        ICE_FLOW_PTYPE_MAX);
 471                         hdrs &= ~ICE_FLOW_SEG_HDR_TCP;
 472                 } else if (hdrs & ICE_FLOW_SEG_HDR_SCTP) {
 473                         src = (const ice_bitmap_t *)ice_ptypes_sctp_il;
 474                         ice_and_bitmap(params->ptypes, params->ptypes, src,
 475                                        ICE_FLOW_PTYPE_MAX);
 476                         hdrs &= ~ICE_FLOW_SEG_HDR_SCTP;
 477                 } else if (hdrs & ICE_FLOW_SEG_HDR_GRE) {
 478                         if (!i) {
 479                                 src = (const ice_bitmap_t *)ice_ptypes_gre_of;
 480                                 ice_and_bitmap(params->ptypes, params->ptypes,
 481                                                src, ICE_FLOW_PTYPE_MAX);
 482                         }
 483                         hdrs &= ~ICE_FLOW_SEG_HDR_GRE;
 484                 }
 485         }
 486
 487         return ICE_SUCCESS;
 488 }
 489
 490 /**
 491  * ice_flow_xtract_pkt_flags - Create an extr sequence entry for packet flags
 492  * @hw: pointer to the HW struct
 493  * @params: information about the flow to be processed
 494  * @flags: The value of pkt_flags[x:x] in RX/TX MDID metadata.
 495  *
 496  * This function will allocate an extraction sequence entries for a DWORD size
 497  * chunk of the packet flags.
 498  */
 499 static enum ice_status
 500 ice_flow_xtract_pkt_flags(struct ice_hw *hw,
 501                           struct ice_flow_prof_params *params,
 502                           enum ice_flex_mdid_pkt_flags flags)
 503 {
 504         u8 fv_words = hw->blk[params->blk].es.fvw;
 505         u8 idx;
 506
 507         /* Make sure the number of extraction sequence entries required does not
 508          * exceed the block's capacity.
 509          */
 510         if (params->es_cnt >= fv_words)
 511                 return ICE_ERR_MAX_LIMIT;
 512
 513         /* some blocks require a reversed field vector layout */
 514         if (hw->blk[params->blk].es.reverse)
 515                 idx = fv_words - params->es_cnt - 1;
 516         else
 517                 idx = params->es_cnt;
 518
 519         params->es[idx].prot_id = ICE_PROT_META_ID;
 520         params->es[idx].off = flags;
 521         params->es_cnt++;
 522
 523         return ICE_SUCCESS;
 524 }
 525
 526 /**
 527  * ice_flow_xtract_fld - Create an extraction sequence entry for the given field
 528  * @hw: pointer to the HW struct
 529  * @params: information about the flow to be processed
 530  * @seg: packet segment index of the field to be extracted
 531  * @fld: ID of field to be extracted
 532  *
 533  * This function determines the protocol ID, offset, and size of the given
 534  * field. It then allocates one or more extraction sequence entries for the
 535  * given field, and fill the entries with protocol ID and offset information.
 536  */
 537 static enum ice_status
 538 ice_flow_xtract_fld(struct ice_hw *hw, struct ice_flow_prof_params *params,
 539                     u8 seg, enum ice_flow_field fld)
 540 {
 541         enum ice_flow_field sib = ICE_FLOW_FIELD_IDX_MAX;
 542         enum ice_prot_id prot_id = ICE_PROT_ID_INVAL;
 543         u8 fv_words = hw->blk[params->blk].es.fvw;
 544         struct ice_flow_fld_info *flds;
 545         u16 cnt, ese_bits, i;
 546         s16 adj = 0;
 547         u16 off;
 548
 549         flds = params->prof->segs[seg].fields;
 550
 551         switch (fld) {
 552         case ICE_FLOW_FIELD_IDX_ETH_DA:
 553         case ICE_FLOW_FIELD_IDX_ETH_SA:
 554         case ICE_FLOW_FIELD_IDX_S_VLAN:
 555         case ICE_FLOW_FIELD_IDX_C_VLAN:
 556                 prot_id = seg == 0 ? ICE_PROT_MAC_OF_OR_S : ICE_PROT_MAC_IL;
 557                 break;
 558         case ICE_FLOW_FIELD_IDX_ETH_TYPE:
 559                 prot_id = seg == 0 ? ICE_PROT_ETYPE_OL : ICE_PROT_ETYPE_IL;
 560                 break;
 561         case ICE_FLOW_FIELD_IDX_IP_DSCP:
 562                 if (params->prof->segs[seg].hdrs & ICE_FLOW_SEG_HDR_IPV6)
 563                         adj = ICE_FLOW_FLD_IPV6_TTL_DSCP_DISP;
 564                 /* Fall through */
 565         case ICE_FLOW_FIELD_IDX_IP_TTL:
 566         case ICE_FLOW_FIELD_IDX_IP_PROT:
 567                 /* Some fields are located at different offsets in IPv4 and
 568                  * IPv6
 569                  */
 570                 if (params->prof->segs[seg].hdrs & ICE_FLOW_SEG_HDR_IPV4) {
 571                         prot_id = seg == 0 ? ICE_PROT_IPV4_OF_OR_S :
 572                                 ICE_PROT_IPV4_IL;
 573                         /* TTL and PROT share the same extraction seq. entry.
 574                          * Each is considered a sibling to the other in term
 575                          * sharing the same extraction sequence entry.
 576                          */
 577                         if (fld == ICE_FLOW_FIELD_IDX_IP_TTL)
 578                                 sib = ICE_FLOW_FIELD_IDX_IP_PROT;
 579                         else if (fld == ICE_FLOW_FIELD_IDX_IP_PROT)
 580                                 sib = ICE_FLOW_FIELD_IDX_IP_TTL;
 581                 } else if (params->prof->segs[seg].hdrs &
 582                            ICE_FLOW_SEG_HDR_IPV6) {
 583                         prot_id = seg == 0 ? ICE_PROT_IPV6_OF_OR_S :
 584                                 ICE_PROT_IPV6_IL;
 585                         if (fld == ICE_FLOW_FIELD_IDX_IP_TTL)
 586                                 adj = ICE_FLOW_FLD_IPV6_TTL_TTL_DISP;
 587                         else if (fld == ICE_FLOW_FIELD_IDX_IP_PROT)
 588                                 adj = ICE_FLOW_FLD_IPV6_TTL_PROT_DISP;
 589                 }
 590                 break;
 591         case ICE_FLOW_FIELD_IDX_IPV4_SA:
 592         case ICE_FLOW_FIELD_IDX_IPV4_DA:
 593                 prot_id = seg == 0 ? ICE_PROT_IPV4_OF_OR_S : ICE_PROT_IPV4_IL;
 594                 break;
 595         case ICE_FLOW_FIELD_IDX_IPV6_SA:
 596         case ICE_FLOW_FIELD_IDX_IPV6_DA:
 597                 prot_id = seg == 0 ? ICE_PROT_IPV6_OF_OR_S : ICE_PROT_IPV6_IL;
 598                 break;
 599         case ICE_FLOW_FIELD_IDX_TCP_SRC_PORT:
 600         case ICE_FLOW_FIELD_IDX_TCP_DST_PORT:
 601         case ICE_FLOW_FIELD_IDX_TCP_FLAGS:
 602                 prot_id = ICE_PROT_TCP_IL;
 603                 break;
 604         case ICE_FLOW_FIELD_IDX_UDP_SRC_PORT:
 605         case ICE_FLOW_FIELD_IDX_UDP_DST_PORT:
 606                 prot_id = seg == 0 ? ICE_PROT_UDP_IL_OR_S : ICE_PROT_UDP_OF;
 607                 break;
 608         case ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT:
 609         case ICE_FLOW_FIELD_IDX_SCTP_DST_PORT:
 610                 prot_id = ICE_PROT_SCTP_IL;
 611                 break;
 612         case ICE_FLOW_FIELD_IDX_ARP_SIP:
 613         case ICE_FLOW_FIELD_IDX_ARP_DIP:
 614         case ICE_FLOW_FIELD_IDX_ARP_SHA:
 615         case ICE_FLOW_FIELD_IDX_ARP_DHA:
 616         case ICE_FLOW_FIELD_IDX_ARP_OP:
 617                 prot_id = ICE_PROT_ARP_OF;
 618                 break;
 619         case ICE_FLOW_FIELD_IDX_ICMP_TYPE:
 620         case ICE_FLOW_FIELD_IDX_ICMP_CODE:
 621                 /* ICMP type and code share the same extraction seq. entry */
 622                 prot_id = (params->prof->segs[seg].hdrs &
 623                            ICE_FLOW_SEG_HDR_IPV4) ?
 624                         ICE_PROT_ICMP_IL : ICE_PROT_ICMPV6_IL;
 625                 sib = fld == ICE_FLOW_FIELD_IDX_ICMP_TYPE ?
 626                         ICE_FLOW_FIELD_IDX_ICMP_CODE :
 627                         ICE_FLOW_FIELD_IDX_ICMP_TYPE;
 628                 break;
 629         case ICE_FLOW_FIELD_IDX_GRE_KEYID:
 630                 prot_id = ICE_PROT_GRE_OF;
 631                 break;
 632         default:
 633                 return ICE_ERR_NOT_IMPL;
 634         }
 635
 636         /* Each extraction sequence entry is a word in size, and extracts a
 637          * word-aligned offset from a protocol header.
 638          */
 639         ese_bits = ICE_FLOW_FV_EXTRACT_SZ * BITS_PER_BYTE;
 640
 641         flds[fld].xtrct.prot_id = prot_id;
 642         flds[fld].xtrct.off = (ice_flds_info[fld].off / ese_bits) *
 643                 ICE_FLOW_FV_EXTRACT_SZ;
 644         flds[fld].xtrct.disp = (u8)((ice_flds_info[fld].off + adj) % ese_bits);
 645         flds[fld].xtrct.idx = params->es_cnt;
 646
 647         /* Adjust the next field-entry index after accommodating the number of
 648          * entries this field consumes
 649          */
 650         cnt = DIVIDE_AND_ROUND_UP(flds[fld].xtrct.disp +
 651                                   ice_flds_info[fld].size, ese_bits);
 652
 653         /* Fill in the extraction sequence entries needed for this field */
 654         off = flds[fld].xtrct.off;
 655         for (i = 0; i < cnt; i++) {
 656                 /* Only consume an extraction sequence entry if there is no
 657                  * sibling field associated with this field or the sibling entry
 658                  * already extracts the word shared with this field.
 659                  */
 660                 if (sib == ICE_FLOW_FIELD_IDX_MAX ||
 661                     flds[sib].xtrct.prot_id == ICE_PROT_ID_INVAL ||
 662                     flds[sib].xtrct.off != off) {
 663                         u8 idx;
 664
 665                         /* Make sure the number of extraction sequence required
 666                          * does not exceed the block's capability
 667                          */
 668                         if (params->es_cnt >= fv_words)
 669                                 return ICE_ERR_MAX_LIMIT;
 670
 671                         /* some blocks require a reversed field vector layout */
 672                         if (hw->blk[params->blk].es.reverse)
 673                                 idx = fv_words - params->es_cnt - 1;
 674                         else
 675                                 idx = params->es_cnt;
 676
 677                         params->es[idx].prot_id = prot_id;
 678                         params->es[idx].off = off;
 679                         params->es_cnt++;
 680                 }
 681
 682                 off += ICE_FLOW_FV_EXTRACT_SZ;
 683         }
 684
 685         return ICE_SUCCESS;
 686 }
 687
 688 /**
 689  * ice_flow_xtract_raws - Create extract sequence entries for raw bytes
 690  * @hw: pointer to the HW struct
 691  * @params: information about the flow to be processed
 692  * @seg: index of packet segment whose raw fields are to be be extracted
 693  */
 694 static enum ice_status
 695 ice_flow_xtract_raws(struct ice_hw *hw, struct ice_flow_prof_params *params,
 696                      u8 seg)
 697 {
 698         u16 hdrs_sz;
 699         u8 i;
 700
 701         if (!params->prof->segs[seg].raws_cnt)
 702                 return ICE_SUCCESS;
 703
 704         if (params->prof->segs[seg].raws_cnt >
 705             ARRAY_SIZE(params->prof->segs[seg].raws))
 706                 return ICE_ERR_MAX_LIMIT;
 707
 708         /* Offsets within the segment headers are not supported */
 709         hdrs_sz = ice_flow_calc_seg_sz(params, seg);
 710         if (!hdrs_sz)
 711                 return ICE_ERR_PARAM;
 712
 713         for (i = 0; i < params->prof->segs[seg].raws_cnt; i++) {
 714                 struct ice_flow_seg_fld_raw *raw;
 715                 u16 off, cnt, j;
 716
 717                 raw = &params->prof->segs[seg].raws[i];
 718
 719                 /* Only support matching raw fields in the payload */
 720                 if (raw->off < hdrs_sz)
 721                         return ICE_ERR_PARAM;
 722
 723                 /* Convert the segment-relative offset into payload-relative
 724                  * offset.
 725                  */
 726                 off = raw->off - hdrs_sz;
 727
 728                 /* Storing extraction information */
 729                 raw->info.xtrct.prot_id = ICE_PROT_PAY;
 730                 raw->info.xtrct.off = (off / ICE_FLOW_FV_EXTRACT_SZ) *
 731                         ICE_FLOW_FV_EXTRACT_SZ;
 732                 raw->info.xtrct.disp = (off % ICE_FLOW_FV_EXTRACT_SZ) *
 733                         BITS_PER_BYTE;
 734                 raw->info.xtrct.idx = params->es_cnt;
 735
 736                 /* Determine the number of field vector entries this raw field
 737                  * consumes.
 738                  */
 739                 cnt = DIVIDE_AND_ROUND_UP(raw->info.xtrct.disp +
 740                                           (raw->info.src.last * BITS_PER_BYTE),
 741                                           (ICE_FLOW_FV_EXTRACT_SZ *
 742                                            BITS_PER_BYTE));
 743                 off = raw->info.xtrct.off;
 744                 for (j = 0; j < cnt; j++) {
 745                         /* Make sure the number of extraction sequence required
 746                          * does not exceed the block's capability
 747                          */
 748                         if (params->es_cnt >= hw->blk[params->blk].es.count ||
 749                             params->es_cnt >= ICE_MAX_FV_WORDS)
 750                                 return ICE_ERR_MAX_LIMIT;
 751
 752                         params->es[params->es_cnt].prot_id = ICE_PROT_PAY;
 753                         params->es[params->es_cnt].off = off;
 754                         params->es_cnt++;
 755                         off += ICE_FLOW_FV_EXTRACT_SZ;
 756                 }
 757         }
 758
 759         return ICE_SUCCESS;
 760 }
 761
 762 /**
 763  * ice_flow_create_xtrct_seq - Create an extraction sequence for given segments
 764  * @hw: pointer to the HW struct
 765  * @params: information about the flow to be processed
 766  *
 767  * This function iterates through all matched fields in the given segments, and
 768  * creates an extraction sequence for the fields.
 769  */
 770 static enum ice_status
 771 ice_flow_create_xtrct_seq(struct ice_hw *hw,
 772                           struct ice_flow_prof_params *params)
 773 {
 774         enum ice_status status = ICE_SUCCESS;
 775         u8 i;
 776
 777         /* For ACL, we also need to extract the direction bit (Rx,Tx) data from
 778          * packet flags
 779          */
 780         if (params->blk == ICE_BLK_ACL)
 781                 ice_flow_xtract_pkt_flags(hw, params,
 782                                           ICE_RX_MDID_PKT_FLAGS_15_0);
 783
 784         for (i = 0; i < params->prof->segs_cnt; i++) {
 785                 u64 match = params->prof->segs[i].match;
 786                 u16 j;
 787
 788                 for (j = 0; j < ICE_FLOW_FIELD_IDX_MAX && match; j++) {
 789                         const u64 bit = BIT_ULL(j);
 790
 791                         if (match & bit) {
 792                                 status = ice_flow_xtract_fld
 793                                         (hw, params, i, (enum ice_flow_field)j);
 794                                 if (status)
 795                                         return status;
 796                                 match &= ~bit;
 797                         }
 798                 }
 799
 800                 /* Process raw matching bytes */
 801                 status = ice_flow_xtract_raws(hw, params, i);
 802                 if (status)
 803                         return status;
 804         }
 805
 806         return status;
 807 }
 808
 809 /**
 810  * ice_flow_proc_segs - process all packet segments associated with a profile
 811  * @hw: pointer to the HW struct
 812  * @params: information about the flow to be processed
 813  */
 814 static enum ice_status
 815 ice_flow_proc_segs(struct ice_hw *hw, struct ice_flow_prof_params *params)
 816 {
 817         enum ice_status status;
 818
 819         status = ice_flow_proc_seg_hdrs(params);
 820         if (status)
 821                 return status;
 822
 823         status = ice_flow_create_xtrct_seq(hw, params);
 824         if (status)
 825                 return status;
 826
 827         switch (params->blk) {
 828         case ICE_BLK_RSS:
 829                 /* Only header information is provided for RSS configuration.
 830                  * No further processing is needed.
 831                  */
 832                 status = ICE_SUCCESS;
 833                 break;
 834         case ICE_BLK_FD:
 835                 status = ICE_SUCCESS;
 836                 break;
 837         case ICE_BLK_SW:
 838         default:
 839                 return ICE_ERR_NOT_IMPL;
 840         }
 841
 842         return status;
 843 }
 844
 845 #define ICE_FLOW_FIND_PROF_CHK_FLDS     0x00000001
 846 #define ICE_FLOW_FIND_PROF_CHK_VSI      0x00000002
 847
 848 /**
 849  * ice_flow_find_prof_conds - Find a profile matching headers and conditions
 850  * @hw: pointer to the HW struct
 851  * @blk: classification stage
 852  * @dir: flow direction
 853  * @segs: array of one or more packet segments that describe the flow
 854  * @segs_cnt: number of packet segments provided
 855  * @vsi_handle: software VSI handle to check VSI (ICE_FLOW_FIND_PROF_CHK_VSI)
 856  * @conds: additional conditions to be checked (ICE_FLOW_FIND_PROF_CHK_*)
 857  */
 858 static struct ice_flow_prof *
 859 ice_flow_find_prof_conds(struct ice_hw *hw, enum ice_block blk,
 860                          enum ice_flow_dir dir, struct ice_flow_seg_info *segs,
 861                          u8 segs_cnt, u16 vsi_handle, u32 conds)
 862 {
 863         struct ice_flow_prof *p;
 864
 865         LIST_FOR_EACH_ENTRY(p, &hw->fl_profs[blk], ice_flow_prof, l_entry) {
 866                 if (p->dir == dir && segs_cnt && segs_cnt == p->segs_cnt) {
 867                         u8 i;
 868
 869                         /* Check for profile-VSI association if specified */
 870                         if ((conds & ICE_FLOW_FIND_PROF_CHK_VSI) &&
 871                             ice_is_vsi_valid(hw, vsi_handle) &&
 872                             !ice_is_bit_set(p->vsis, vsi_handle))
 873                                 continue;
 874
 875                         /* Protocol headers must be checked. Matched fields are
 876                          * checked if specified.
 877                          */
 878                         for (i = 0; i < segs_cnt; i++)
 879                                 if (segs[i].hdrs != p->segs[i].hdrs ||
 880                                     ((conds & ICE_FLOW_FIND_PROF_CHK_FLDS) &&
 881                                      segs[i].match != p->segs[i].match))
 882                                         break;
 883
 884                         /* A match is found if all segments are matched */
 885                         if (i == segs_cnt)
 886                                 return p;
 887                 }
 888         }
 889
 890         return NULL;
 891 }
 892
 893 /**
 894  * ice_flow_find_prof - Look up a profile matching headers and matched fields
 895  * @hw: pointer to the HW struct
 896  * @blk: classification stage
 897  * @dir: flow direction
 898  * @segs: array of one or more packet segments that describe the flow
 899  * @segs_cnt: number of packet segments provided
 900  */
 901 u64
 902 ice_flow_find_prof(struct ice_hw *hw, enum ice_block blk, enum ice_flow_dir dir,
 903                    struct ice_flow_seg_info *segs, u8 segs_cnt)
 904 {
 905         struct ice_flow_prof *p;
 906
 907         ice_acquire_lock(&hw->fl_profs_locks[blk]);
 908         p = ice_flow_find_prof_conds(hw, blk, dir, segs, segs_cnt,
 909                                      ICE_MAX_VSI, ICE_FLOW_FIND_PROF_CHK_FLDS);
 910         ice_release_lock(&hw->fl_profs_locks[blk]);
 911
 912         return p ? p->id : ICE_FLOW_PROF_ID_INVAL;
 913 }
 914
 915 /**
 916  * ice_flow_find_prof_id - Look up a profile with given profile ID
 917  * @hw: pointer to the HW struct
 918  * @blk: classification stage
 919  * @prof_id: unique ID to identify this flow profile
 920  */
 921 static struct ice_flow_prof *
 922 ice_flow_find_prof_id(struct ice_hw *hw, enum ice_block blk, u64 prof_id)
 923 {
 924         struct ice_flow_prof *p;
 925
 926         LIST_FOR_EACH_ENTRY(p, &hw->fl_profs[blk], ice_flow_prof, l_entry) {
 927                 if (p->id == prof_id)
 928                         return p;
 929         }
 930
 931         return NULL;
 932 }
 933
 934 /**
 935  * ice_dealloc_flow_entry - Deallocate flow entry memory
 936  * @hw: pointer to the HW struct
 937  * @entry: flow entry to be removed
 938  */
 939 static void
 940 ice_dealloc_flow_entry(struct ice_hw *hw, struct ice_flow_entry *entry)
 941 {
 942         if (!entry)
 943                 return;
 944
 945         if (entry->entry)
 946                 ice_free(hw, entry->entry);
 947
 948         if (entry->acts) {
 949                 ice_free(hw, entry->acts);
 950                 entry->acts = NULL;
 951                 entry->acts_cnt = 0;
 952         }
 953
 954         ice_free(hw, entry);
 955 }
 956
 957 /**
 958  * ice_flow_rem_entry_sync - Remove a flow entry
 959  * @hw: pointer to the HW struct
 960  * @entry: flow entry to be removed
 961  */
 962 static enum ice_status
 963 ice_flow_rem_entry_sync(struct ice_hw *hw, struct ice_flow_entry *entry)
 964 {
 965         if (!entry)
 966                 return ICE_ERR_BAD_PTR;
 967
 968         LIST_DEL(&entry->l_entry);
 969
 970         ice_dealloc_flow_entry(hw, entry);
 971
 972         return ICE_SUCCESS;
 973 }
 974
 975 /**
 976  * ice_flow_add_prof_sync - Add a flow profile for packet segments and fields
 977  * @hw: pointer to the HW struct
 978  * @blk: classification stage
 979  * @dir: flow direction
 980  * @prof_id: unique ID to identify this flow profile
 981  * @segs: array of one or more packet segments that describe the flow
 982  * @segs_cnt: number of packet segments provided
 983  * @acts: array of default actions
 984  * @acts_cnt: number of default actions
 985  * @prof: stores the returned flow profile added
 986  *
 987  * Assumption: the caller has acquired the lock to the profile list
 988  */
 989 static enum ice_status
 990 ice_flow_add_prof_sync(struct ice_hw *hw, enum ice_block blk,
 991                        enum ice_flow_dir dir, u64 prof_id,
 992                        struct ice_flow_seg_info *segs, u8 segs_cnt,
 993                        struct ice_flow_action *acts, u8 acts_cnt,
 994                        struct ice_flow_prof **prof)
 995 {
 996         struct ice_flow_prof_params params;
 997         enum ice_status status = ICE_SUCCESS;
 998         u8 i;
 999
1000         if (!prof || (acts_cnt && !acts))
1001                 return ICE_ERR_BAD_PTR;
1002
1003         ice_memset(&params, 0, sizeof(params), ICE_NONDMA_MEM);
1004         params.prof = (struct ice_flow_prof *)
1005                 ice_malloc(hw, sizeof(*params.prof));
1006         if (!params.prof)
1007                 return ICE_ERR_NO_MEMORY;
1008
1009         /* initialize extraction sequence to all invalid (0xff) */
1010         for (i = 0; i < ICE_MAX_FV_WORDS; i++) {
1011                 params.es[i].prot_id = ICE_PROT_INVALID;
1012                 params.es[i].off = ICE_FV_OFFSET_INVAL;
1013         }
1014
1015         params.blk = blk;
1016         params.prof->id = prof_id;
1017         params.prof->dir = dir;
1018         params.prof->segs_cnt = segs_cnt;
1019
1020         /* Make a copy of the segments that need to be persistent in the flow
1021          * profile instance
1022          */
1023         for (i = 0; i < segs_cnt; i++)
1024                 ice_memcpy(&params.prof->segs[i], &segs[i], sizeof(*segs),
1025                            ICE_NONDMA_TO_NONDMA);
1026
1027         /* Make a copy of the actions that need to be persistent in the flow
1028          * profile instance.
1029          */
1030         if (acts_cnt) {
1031                 params.prof->acts = (struct ice_flow_action *)
1032                         ice_memdup(hw, acts, acts_cnt * sizeof(*acts),
1033                                    ICE_NONDMA_TO_NONDMA);
1034
1035                 if (!params.prof->acts) {
1036                         status = ICE_ERR_NO_MEMORY;
1037                         goto out;
1038                 }
1039         }
1040
1041         status = ice_flow_proc_segs(hw, &params);
1042         if (status) {
1043                 ice_debug(hw, ICE_DBG_FLOW,
1044                           "Error processing a flow's packet segments\n");
1045                 goto out;
1046         }
1047
1048         /* Add a HW profile for this flow profile */
1049         status = ice_add_prof(hw, blk, prof_id, (u8 *)params.ptypes, params.es);
1050         if (status) {
1051                 ice_debug(hw, ICE_DBG_FLOW, "Error adding a HW flow profile\n");
1052                 goto out;
1053         }
1054
1055         INIT_LIST_HEAD(&params.prof->entries);
1056         ice_init_lock(&params.prof->entries_lock);
1057         *prof = params.prof;
1058
1059 out:
1060         if (status) {
1061                 if (params.prof->acts)
1062                         ice_free(hw, params.prof->acts);
1063                 ice_free(hw, params.prof);
1064         }
1065
1066         return status;
1067 }
1068
1069 /**
1070  * ice_flow_rem_prof_sync - remove a flow profile
1071  * @hw: pointer to the hardware structure
1072  * @blk: classification stage
1073  * @prof: pointer to flow profile to remove
1074  *
1075  * Assumption: the caller has acquired the lock to the profile list
1076  */
1077 static enum ice_status
1078 ice_flow_rem_prof_sync(struct ice_hw *hw, enum ice_block blk,
1079                        struct ice_flow_prof *prof)
1080 {
1081         enum ice_status status = ICE_SUCCESS;
1082
1083         /* Remove all remaining flow entries before removing the flow profile */
1084         if (!LIST_EMPTY(&prof->entries)) {
1085                 struct ice_flow_entry *e, *t;
1086
1087                 ice_acquire_lock(&prof->entries_lock);
1088
1089                 LIST_FOR_EACH_ENTRY_SAFE(e, t, &prof->entries, ice_flow_entry,
1090                                          l_entry) {
1091                         status = ice_flow_rem_entry_sync(hw, e);
1092                         if (status)
1093                                 break;
1094                 }
1095
1096                 ice_release_lock(&prof->entries_lock);
1097         }
1098
1099         /* Remove all hardware profiles associated with this flow profile */
1100         status = ice_rem_prof(hw, blk, prof->id);
1101         if (!status) {
1102                 LIST_DEL(&prof->l_entry);
1103                 ice_destroy_lock(&prof->entries_lock);
1104                 if (prof->acts)
1105                         ice_free(hw, prof->acts);
1106                 ice_free(hw, prof);
1107         }
1108
1109         return status;
1110 }
1111
1112 /**
1113  * ice_flow_assoc_prof - associate a VSI with a flow profile
1114  * @hw: pointer to the hardware structure
1115  * @blk: classification stage
1116  * @prof: pointer to flow profile
1117  * @vsi_handle: software VSI handle
1118  *
1119  * Assumption: the caller has acquired the lock to the profile list
1120  * and the software VSI handle has been validated
1121  */
1122 static enum ice_status
1123 ice_flow_assoc_prof(struct ice_hw *hw, enum ice_block blk,
1124                     struct ice_flow_prof *prof, u16 vsi_handle)
1125 {
1126         enum ice_status status = ICE_SUCCESS;
1127
1128         if (!ice_is_bit_set(prof->vsis, vsi_handle)) {
1129                 status = ice_add_prof_id_flow(hw, blk,
1130                                               ice_get_hw_vsi_num(hw,
1131                                                                  vsi_handle),
1132                                               prof->id);
1133                 if (!status)
1134                         ice_set_bit(vsi_handle, prof->vsis);
1135                 else
1136                         ice_debug(hw, ICE_DBG_FLOW,
1137                                   "HW profile add failed, %d\n",
1138                                   status);
1139         }
1140
1141         return status;
1142 }
1143
1144 /**
1145  * ice_flow_disassoc_prof - disassociate a VSI from a flow profile
1146  * @hw: pointer to the hardware structure
1147  * @blk: classification stage
1148  * @prof: pointer to flow profile
1149  * @vsi_handle: software VSI handle
1150  *
1151  * Assumption: the caller has acquired the lock to the profile list
1152  * and the software VSI handle has been validated
1153  */
1154 static enum ice_status
1155 ice_flow_disassoc_prof(struct ice_hw *hw, enum ice_block blk,
1156                        struct ice_flow_prof *prof, u16 vsi_handle)
1157 {
1158         enum ice_status status = ICE_SUCCESS;
1159
1160         if (ice_is_bit_set(prof->vsis, vsi_handle)) {
1161                 status = ice_rem_prof_id_flow(hw, blk,
1162                                               ice_get_hw_vsi_num(hw,
1163                                                                  vsi_handle),
1164                                               prof->id);
1165                 if (!status)
1166                         ice_clear_bit(vsi_handle, prof->vsis);
1167                 else
1168                         ice_debug(hw, ICE_DBG_FLOW,
1169                                   "HW profile remove failed, %d\n",
1170                                   status);
1171         }
1172
1173         return status;
1174 }
1175
1176 /**
1177  * ice_flow_add_prof - Add a flow profile for packet segments and matched fields
1178  * @hw: pointer to the HW struct
1179  * @blk: classification stage
1180  * @dir: flow direction
1181  * @prof_id: unique ID to identify this flow profile
1182  * @segs: array of one or more packet segments that describe the flow
1183  * @segs_cnt: number of packet segments provided
1184  * @acts: array of default actions
1185  * @acts_cnt: number of default actions
1186  * @prof: stores the returned flow profile added
1187  */
1188 enum ice_status
1189 ice_flow_add_prof(struct ice_hw *hw, enum ice_block blk, enum ice_flow_dir dir,
1190                   u64 prof_id, struct ice_flow_seg_info *segs, u8 segs_cnt,
1191                   struct ice_flow_action *acts, u8 acts_cnt,
1192                   struct ice_flow_prof **prof)
1193 {
1194         enum ice_status status;
1195
1196         if (segs_cnt > ICE_FLOW_SEG_MAX)
1197                 return ICE_ERR_MAX_LIMIT;
1198
1199         if (!segs_cnt)
1200                 return ICE_ERR_PARAM;
1201
1202         if (!segs)
1203                 return ICE_ERR_BAD_PTR;
1204
1205         status = ice_flow_val_hdrs(segs, segs_cnt);
1206         if (status)
1207                 return status;
1208
1209         ice_acquire_lock(&hw->fl_profs_locks[blk]);
1210
1211         status = ice_flow_add_prof_sync(hw, blk, dir, prof_id, segs, segs_cnt,
1212                                         acts, acts_cnt, prof);
1213         if (!status)
1214                 LIST_ADD(&(*prof)->l_entry, &hw->fl_profs[blk]);
1215
1216         ice_release_lock(&hw->fl_profs_locks[blk]);
1217
1218         return status;
1219 }
1220
1221 /**
1222  * ice_flow_rem_prof - Remove a flow profile and all entries associated with it
1223  * @hw: pointer to the HW struct
1224  * @blk: the block for which the flow profile is to be removed
1225  * @prof_id: unique ID of the flow profile to be removed
1226  */
1227 enum ice_status
1228 ice_flow_rem_prof(struct ice_hw *hw, enum ice_block blk, u64 prof_id)
1229 {
1230         struct ice_flow_prof *prof;
1231         enum ice_status status;
1232
1233         ice_acquire_lock(&hw->fl_profs_locks[blk]);
1234
1235         prof = ice_flow_find_prof_id(hw, blk, prof_id);
1236         if (!prof) {
1237                 status = ICE_ERR_DOES_NOT_EXIST;
1238                 goto out;
1239         }
1240
1241         /* prof becomes invalid after the call */
1242         status = ice_flow_rem_prof_sync(hw, blk, prof);
1243
1244 out:
1245         ice_release_lock(&hw->fl_profs_locks[blk]);
1246
1247         return status;
1248 }
1249
1250 /**
1251  * ice_flow_get_hw_prof - return the HW profile for a specific profile ID handle
1252  * @hw: pointer to the HW struct
1253  * @blk: classification stage
1254  * @prof_id: the profile ID handle
1255  * @hw_prof_id: pointer to variable to receive the HW profile ID
1256  */
1257 enum ice_status
1258 ice_flow_get_hw_prof(struct ice_hw *hw, enum ice_block blk, u64 prof_id,
1259                      u8 *hw_prof_id)
1260 {
1261         struct ice_prof_map *map;
1262
1263         map = ice_search_prof_id(hw, blk, prof_id);
1264         if (map) {
1265                 *hw_prof_id = map->prof_id;
1266                 return ICE_SUCCESS;
1267         }
1268
1269         return ICE_ERR_DOES_NOT_EXIST;
1270 }
1271
1272 /**
1273  * ice_flow_find_entry - look for a flow entry using its unique ID
1274  * @hw: pointer to the HW struct
1275  * @blk: classification stage
1276  * @entry_id: unique ID to identify this flow entry
1277  *
1278  * This function looks for the flow entry with the specified unique ID in all
1279  * flow profiles of the specified classification stage. If the entry is found,
1280  * and it returns the handle to the flow entry. Otherwise, it returns
1281  * ICE_FLOW_ENTRY_ID_INVAL.
1282  */
1283 u64 ice_flow_find_entry(struct ice_hw *hw, enum ice_block blk, u64 entry_id)
1284 {
1285         struct ice_flow_entry *found = NULL;
1286         struct ice_flow_prof *p;
1287
1288         ice_acquire_lock(&hw->fl_profs_locks[blk]);
1289
1290         LIST_FOR_EACH_ENTRY(p, &hw->fl_profs[blk], ice_flow_prof, l_entry) {
1291                 struct ice_flow_entry *e;
1292
1293                 ice_acquire_lock(&p->entries_lock);
1294                 LIST_FOR_EACH_ENTRY(e, &p->entries, ice_flow_entry, l_entry)
1295                         if (e->id == entry_id) {
1296                                 found = e;
1297                                 break;
1298                         }
1299                 ice_release_lock(&p->entries_lock);
1300
1301                 if (found)
1302                         break;
1303         }
1304
1305         ice_release_lock(&hw->fl_profs_locks[blk]);
1306
1307         return found ? ICE_FLOW_ENTRY_HNDL(found) : ICE_FLOW_ENTRY_HANDLE_INVAL;
1308 }
1309
1310 /**
1311  * ice_flow_add_entry - Add a flow entry
1312  * @hw: pointer to the HW struct
1313  * @blk: classification stage
1314  * @prof_id: ID of the profile to add a new flow entry to
1315  * @entry_id: unique ID to identify this flow entry
1316  * @vsi_handle: software VSI handle for the flow entry
1317  * @prio: priority of the flow entry
1318  * @data: pointer to a data buffer containing flow entry's match values/masks
1319  * @acts: arrays of actions to be performed on a match
1320  * @acts_cnt: number of actions
1321  * @entry_h: pointer to buffer that receives the new flow entry's handle
1322  */
1323 enum ice_status
1324 ice_flow_add_entry(struct ice_hw *hw, enum ice_block blk, u64 prof_id,
1325                    u64 entry_id, u16 vsi_handle, enum ice_flow_priority prio,
1326                    void *data, struct ice_flow_action *acts, u8 acts_cnt,
1327                    u64 *entry_h)
1328 {
1329         struct ice_flow_prof *prof = NULL;
1330         struct ice_flow_entry *e = NULL;
1331         enum ice_status status = ICE_SUCCESS;
1332
1333         if (acts_cnt && !acts)
1334                 return ICE_ERR_PARAM;
1335
1336         /* No flow entry data is expected for RSS */
1337         if (!entry_h || (!data && blk != ICE_BLK_RSS))
1338                 return ICE_ERR_BAD_PTR;
1339
1340         if (!ice_is_vsi_valid(hw, vsi_handle))
1341                 return ICE_ERR_PARAM;
1342
1343         ice_acquire_lock(&hw->fl_profs_locks[blk]);
1344
1345         prof = ice_flow_find_prof_id(hw, blk, prof_id);
1346         if (!prof) {
1347                 status = ICE_ERR_DOES_NOT_EXIST;
1348         } else {
1349                 /* Allocate memory for the entry being added and associate
1350                  * the VSI to the found flow profile
1351                  */
1352                 e = (struct ice_flow_entry *)ice_malloc(hw, sizeof(*e));
1353                 if (!e)
1354                         status = ICE_ERR_NO_MEMORY;
1355                 else
1356                         status = ice_flow_assoc_prof(hw, blk, prof, vsi_handle);
1357         }
1358
1359         ice_release_lock(&hw->fl_profs_locks[blk]);
1360         if (status)
1361                 goto out;
1362
1363         e->id = entry_id;
1364         e->vsi_handle = vsi_handle;
1365         e->prof = prof;
1366         e->priority = prio;
1367
1368         switch (blk) {
1369         case ICE_BLK_RSS:
1370                 /* RSS will add only one entry per VSI per profile */
1371                 break;
1372         case ICE_BLK_FD:
1373                 break;
1374         case ICE_BLK_SW:
1375         case ICE_BLK_PE:
1376         default:
1377                 status = ICE_ERR_NOT_IMPL;
1378                 goto out;
1379         }
1380
1381         ice_acquire_lock(&prof->entries_lock);
1382         LIST_ADD(&e->l_entry, &prof->entries);
1383         ice_release_lock(&prof->entries_lock);
1384
1385         *entry_h = ICE_FLOW_ENTRY_HNDL(e);
1386
1387 out:
1388         if (status && e) {
1389                 if (e->entry)
1390                         ice_free(hw, e->entry);
1391                 ice_free(hw, e);
1392         }
1393
1394         return status;
1395 }
1396
1397 /**
1398  * ice_flow_rem_entry - Remove a flow entry
1399  * @hw: pointer to the HW struct
1400  * @entry_h: handle to the flow entry to be removed
1401  */
1402 enum ice_status ice_flow_rem_entry(struct ice_hw *hw, u64 entry_h)
1403 {
1404         struct ice_flow_entry *entry;
1405         struct ice_flow_prof *prof;
1406         enum ice_status status;
1407
1408         if (entry_h == ICE_FLOW_ENTRY_HANDLE_INVAL)
1409                 return ICE_ERR_PARAM;
1410
1411         entry = ICE_FLOW_ENTRY_PTR((unsigned long)entry_h);
1412
1413         /* Retain the pointer to the flow profile as the entry will be freed */
1414         prof = entry->prof;
1415
1416         ice_acquire_lock(&prof->entries_lock);
1417         status = ice_flow_rem_entry_sync(hw, entry);
1418         ice_release_lock(&prof->entries_lock);
1419
1420         return status;
1421 }
1422
1423 /**
1424  * ice_flow_set_fld_ext - specifies locations of field from entry's input buffer
1425  * @seg: packet segment the field being set belongs to
1426  * @fld: field to be set
1427  * @type: type of the field
1428  * @val_loc: if not ICE_FLOW_FLD_OFF_INVAL, location of the value to match from
1429  *           entry's input buffer
1430  * @mask_loc: if not ICE_FLOW_FLD_OFF_INVAL, location of mask value from entry's
1431  *            input buffer
1432  * @last_loc: if not ICE_FLOW_FLD_OFF_INVAL, location of last/upper value from
1433  *            entry's input buffer
1434  *
1435  * This helper function stores information of a field being matched, including
1436  * the type of the field and the locations of the value to match, the mask, and
1437  * and the upper-bound value in the start of the input buffer for a flow entry.
1438  * This function should only be used for fixed-size data structures.
1439  *
1440  * This function also opportunistically determines the protocol headers to be
1441  * present based on the fields being set. Some fields cannot be used alone to
1442  * determine the protocol headers present. Sometimes, fields for particular
1443  * protocol headers are not matched. In those cases, the protocol headers
1444  * must be explicitly set.
1445  */
1446 static void
1447 ice_flow_set_fld_ext(struct ice_flow_seg_info *seg, enum ice_flow_field fld,
1448                      enum ice_flow_fld_match_type type, u16 val_loc,
1449                      u16 mask_loc, u16 last_loc)
1450 {
1451         u64 bit = BIT_ULL(fld);
1452
1453         seg->match |= bit;
1454         if (type == ICE_FLOW_FLD_TYPE_RANGE)
1455                 seg->range |= bit;
1456
1457         seg->fields[fld].type = type;
1458         seg->fields[fld].src.val = val_loc;
1459         seg->fields[fld].src.mask = mask_loc;
1460         seg->fields[fld].src.last = last_loc;
1461
1462         ICE_FLOW_SET_HDRS(seg, ice_flds_info[fld].hdr);
1463 }
1464
1465 /**
1466  * ice_flow_set_fld - specifies locations of field from entry's input buffer
1467  * @seg: packet segment the field being set belongs to
1468  * @fld: field to be set
1469  * @val_loc: if not ICE_FLOW_FLD_OFF_INVAL, location of the value to match from
1470  *           entry's input buffer
1471  * @mask_loc: if not ICE_FLOW_FLD_OFF_INVAL, location of mask value from entry's
1472  *            input buffer
1473  * @last_loc: if not ICE_FLOW_FLD_OFF_INVAL, location of last/upper value from
1474  *            entry's input buffer
1475  * @range: indicate if field being matched is to be in a range
1476  *
1477  * This function specifies the locations, in the form of byte offsets from the
1478  * start of the input buffer for a flow entry, from where the value to match,
1479  * the mask value, and upper value can be extracted. These locations are then
1480  * stored in the flow profile. When adding a flow entry associated with the
1481  * flow profile, these locations will be used to quickly extract the values and
1482  * create the content of a match entry. This function should only be used for
1483  * fixed-size data structures.
1484  */
1485 void
1486 ice_flow_set_fld(struct ice_flow_seg_info *seg, enum ice_flow_field fld,
1487                  u16 val_loc, u16 mask_loc, u16 last_loc, bool range)
1488 {
1489         enum ice_flow_fld_match_type t = range ?
1490                 ICE_FLOW_FLD_TYPE_RANGE : ICE_FLOW_FLD_TYPE_REG;
1491
1492         ice_flow_set_fld_ext(seg, fld, t, val_loc, mask_loc, last_loc);
1493 }
1494
1495 /**
1496  * ice_flow_set_fld_prefix - sets locations of prefix field from entry's buf
1497  * @seg: packet segment the field being set belongs to
1498  * @fld: field to be set
1499  * @val_loc: if not ICE_FLOW_FLD_OFF_INVAL, location of the value to match from
1500  *           entry's input buffer
1501  * @pref_loc: location of prefix value from entry's input buffer
1502  * @pref_sz: size of the location holding the prefix value
1503  *
1504  * This function specifies the locations, in the form of byte offsets from the
1505  * start of the input buffer for a flow entry, from where the value to match
1506  * and the IPv4 prefix value can be extracted. These locations are then stored
1507  * in the flow profile. When adding flow entries to the associated flow profile,
1508  * these locations can be used to quickly extract the values to create the
1509  * content of a match entry. This function should only be used for fixed-size
1510  * data structures.
1511  */
1512 void
1513 ice_flow_set_fld_prefix(struct ice_flow_seg_info *seg, enum ice_flow_field fld,
1514                         u16 val_loc, u16 pref_loc, u8 pref_sz)
1515 {
1516         /* For this type of field, the "mask" location is for the prefix value's
1517          * location and the "last" location is for the size of the location of
1518          * the prefix value.
1519          */
1520         ice_flow_set_fld_ext(seg, fld, ICE_FLOW_FLD_TYPE_PREFIX, val_loc,
1521                              pref_loc, (u16)pref_sz);
1522 }
1523
1524 /**
1525  * ice_flow_add_fld_raw - sets locations of a raw field from entry's input buf
1526  * @seg: packet segment the field being set belongs to
1527  * @off: offset of the raw field from the beginning of the segment in bytes
1528  * @len: length of the raw pattern to be matched
1529  * @val_loc: location of the value to match from entry's input buffer
1530  * @mask_loc: location of mask value from entry's input buffer
1531  *
1532  * This function specifies the offset of the raw field to be match from the
1533  * beginning of the specified packet segment, and the locations, in the form of
1534  * byte offsets from the start of the input buffer for a flow entry, from where
1535  * the value to match and the mask value to be extracted. These locations are
1536  * then stored in the flow profile. When adding flow entries to the associated
1537  * flow profile, these locations can be used to quickly extract the values to
1538  * create the content of a match entry. This function should only be used for
1539  * fixed-size data structures.
1540  */
1541 void
1542 ice_flow_add_fld_raw(struct ice_flow_seg_info *seg, u16 off, u8 len,
1543                      u16 val_loc, u16 mask_loc)
1544 {
1545         if (seg->raws_cnt < ICE_FLOW_SEG_RAW_FLD_MAX) {
1546                 seg->raws[seg->raws_cnt].off = off;
1547                 seg->raws[seg->raws_cnt].info.type = ICE_FLOW_FLD_TYPE_SIZE;
1548                 seg->raws[seg->raws_cnt].info.src.val = val_loc;
1549                 seg->raws[seg->raws_cnt].info.src.mask = mask_loc;
1550                 /* The "last" field is used to store the length of the field */
1551                 seg->raws[seg->raws_cnt].info.src.last = len;
1552         }
1553
1554         /* Overflows of "raws" will be handled as an error condition later in
1555          * the flow when this information is processed.
1556          */
1557         seg->raws_cnt++;
1558 }
1559
1560 #define ICE_FLOW_RSS_SEG_HDR_L3_MASKS \
1561         (ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV6)
1562
1563 #define ICE_FLOW_RSS_SEG_HDR_L4_MASKS \
1564         (ICE_FLOW_SEG_HDR_TCP | ICE_FLOW_SEG_HDR_UDP | \
1565          ICE_FLOW_SEG_HDR_SCTP)
1566
1567 #define ICE_FLOW_RSS_SEG_HDR_VAL_MASKS \
1568         (ICE_FLOW_RSS_SEG_HDR_L3_MASKS | \
1569          ICE_FLOW_RSS_SEG_HDR_L4_MASKS)
1570
1571 /**
1572  * ice_flow_set_rss_seg_info - setup packet segments for RSS
1573  * @segs: pointer to the flow field segment(s)
1574  * @hash_fields: fields to be hashed on for the segment(s)
1575  * @flow_hdr: protocol header fields within a packet segment
1576  *
1577  * Helper function to extract fields from hash bitmap and use flow
1578  * header value to set flow field segment for further use in flow
1579  * profile entry or removal.
1580  */
1581 static enum ice_status
1582 ice_flow_set_rss_seg_info(struct ice_flow_seg_info *segs, u64 hash_fields,
1583                           u32 flow_hdr)
1584 {
1585         u64 val = hash_fields;
1586         u8 i;
1587
1588         for (i = 0; val && i < ICE_FLOW_FIELD_IDX_MAX; i++) {
1589                 u64 bit = BIT_ULL(i);
1590
1591                 if (val & bit) {
1592                         ice_flow_set_fld(segs, (enum ice_flow_field)i,
1593                                          ICE_FLOW_FLD_OFF_INVAL,
1594                                          ICE_FLOW_FLD_OFF_INVAL,
1595                                          ICE_FLOW_FLD_OFF_INVAL, false);
1596                         val &= ~bit;
1597                 }
1598         }
1599         ICE_FLOW_SET_HDRS(segs, flow_hdr);
1600
1601         if (segs->hdrs & ~ICE_FLOW_RSS_SEG_HDR_VAL_MASKS)
1602                 return ICE_ERR_PARAM;
1603
1604         val = (u64)(segs->hdrs & ICE_FLOW_RSS_SEG_HDR_L3_MASKS);
1605         if (!ice_is_pow2(val))
1606                 return ICE_ERR_CFG;
1607
1608         val = (u64)(segs->hdrs & ICE_FLOW_RSS_SEG_HDR_L4_MASKS);
1609         if (val && !ice_is_pow2(val))
1610                 return ICE_ERR_CFG;
1611
1612         return ICE_SUCCESS;
1613 }
1614
1615 /**
1616  * ice_rem_vsi_rss_list - remove VSI from RSS list
1617  * @hw: pointer to the hardware structure
1618  * @vsi_handle: software VSI handle
1619  *
1620  * Remove the VSI from all RSS configurations in the list.
1621  */
1622 void ice_rem_vsi_rss_list(struct ice_hw *hw, u16 vsi_handle)
1623 {
1624         struct ice_rss_cfg *r, *tmp;
1625
1626         if (LIST_EMPTY(&hw->rss_list_head))
1627                 return;
1628
1629         ice_acquire_lock(&hw->rss_locks);
1630         LIST_FOR_EACH_ENTRY_SAFE(r, tmp, &hw->rss_list_head,
1631                                  ice_rss_cfg, l_entry) {
1632                 if (ice_is_bit_set(r->vsis, vsi_handle)) {
1633                         ice_clear_bit(vsi_handle, r->vsis);
1634
1635                         if (!ice_is_any_bit_set(r->vsis, ICE_MAX_VSI)) {
1636                                 LIST_DEL(&r->l_entry);
1637                                 ice_free(hw, r);
1638                         }
1639                 }
1640         }
1641         ice_release_lock(&hw->rss_locks);
1642 }
1643
1644 /**
1645  * ice_rem_vsi_rss_cfg - remove RSS configurations associated with VSI
1646  * @hw: pointer to the hardware structure
1647  * @vsi_handle: software VSI handle
1648  *
1649  * This function will iterate through all flow profiles and disassociate
1650  * the VSI from that profile. If the flow profile has no VSIs it will
1651  * be removed.
1652  */
1653 enum ice_status ice_rem_vsi_rss_cfg(struct ice_hw *hw, u16 vsi_handle)
1654 {
1655         const enum ice_block blk = ICE_BLK_RSS;
1656         struct ice_flow_prof *p, *t;
1657         enum ice_status status = ICE_SUCCESS;
1658
1659         if (!ice_is_vsi_valid(hw, vsi_handle))
1660                 return ICE_ERR_PARAM;
1661
1662         if (LIST_EMPTY(&hw->fl_profs[blk]))
1663                 return ICE_SUCCESS;
1664
1665         ice_acquire_lock(&hw->fl_profs_locks[blk]);
1666         LIST_FOR_EACH_ENTRY_SAFE(p, t, &hw->fl_profs[blk], ice_flow_prof,
1667                                  l_entry) {
1668                 if (ice_is_bit_set(p->vsis, vsi_handle)) {
1669                         status = ice_flow_disassoc_prof(hw, blk, p, vsi_handle);
1670                         if (status)
1671                                 break;
1672
1673                         if (!ice_is_any_bit_set(p->vsis, ICE_MAX_VSI)) {
1674                                 status = ice_flow_rem_prof_sync(hw, blk, p);
1675                                 if (status)
1676                                         break;
1677                         }
1678                 }
1679         }
1680         ice_release_lock(&hw->fl_profs_locks[blk]);
1681
1682         return status;
1683 }
1684
1685 /**
1686  * ice_rem_rss_list - remove RSS configuration from list
1687  * @hw: pointer to the hardware structure
1688  * @vsi_handle: software VSI handle
1689  * @prof: pointer to flow profile
1690  *
1691  * Assumption: lock has already been acquired for RSS list
1692  */
1693 static void
1694 ice_rem_rss_list(struct ice_hw *hw, u16 vsi_handle, struct ice_flow_prof *prof)
1695 {
1696         struct ice_rss_cfg *r, *tmp;
1697
1698         /* Search for RSS hash fields associated to the VSI that match the
1699          * hash configurations associated to the flow profile. If found
1700          * remove from the RSS entry list of the VSI context and delete entry.
1701          */
1702         LIST_FOR_EACH_ENTRY_SAFE(r, tmp, &hw->rss_list_head,
1703                                  ice_rss_cfg, l_entry) {
1704                 if (r->hashed_flds == prof->segs[prof->segs_cnt - 1].match &&
1705                     r->packet_hdr == prof->segs[prof->segs_cnt - 1].hdrs) {
1706                         ice_clear_bit(vsi_handle, r->vsis);
1707                         if (!ice_is_any_bit_set(r->vsis, ICE_MAX_VSI)) {
1708                                 LIST_DEL(&r->l_entry);
1709                                 ice_free(hw, r);
1710                         }
1711                         return;
1712                 }
1713         }
1714 }
1715
1716 /**
1717  * ice_add_rss_list - add RSS configuration to list
1718  * @hw: pointer to the hardware structure
1719  * @vsi_handle: software VSI handle
1720  * @prof: pointer to flow profile
1721  *
1722  * Assumption: lock has already been acquired for RSS list
1723  */
1724 static enum ice_status
1725 ice_add_rss_list(struct ice_hw *hw, u16 vsi_handle, struct ice_flow_prof *prof)
1726 {
1727         struct ice_rss_cfg *r, *rss_cfg;
1728
1729         LIST_FOR_EACH_ENTRY(r, &hw->rss_list_head,
1730                             ice_rss_cfg, l_entry)
1731                 if (r->hashed_flds == prof->segs[prof->segs_cnt - 1].match &&
1732                     r->packet_hdr == prof->segs[prof->segs_cnt - 1].hdrs) {
1733                         ice_set_bit(vsi_handle, r->vsis);
1734                         return ICE_SUCCESS;
1735                 }
1736
1737         rss_cfg = (struct ice_rss_cfg *)ice_malloc(hw, sizeof(*rss_cfg));
1738         if (!rss_cfg)
1739                 return ICE_ERR_NO_MEMORY;
1740
1741         rss_cfg->hashed_flds = prof->segs[prof->segs_cnt - 1].match;
1742         rss_cfg->packet_hdr = prof->segs[prof->segs_cnt - 1].hdrs;
1743         ice_set_bit(vsi_handle, rss_cfg->vsis);
1744
1745         LIST_ADD_TAIL(&rss_cfg->l_entry, &hw->rss_list_head);
1746
1747         return ICE_SUCCESS;
1748 }
1749
1750 #define ICE_FLOW_PROF_HASH_S    0
1751 #define ICE_FLOW_PROF_HASH_M    (0xFFFFFFFFULL << ICE_FLOW_PROF_HASH_S)
1752 #define ICE_FLOW_PROF_HDR_S     32
1753 #define ICE_FLOW_PROF_HDR_M     (0xFFFFFFFFULL << ICE_FLOW_PROF_HDR_S)
1754
1755 #define ICE_FLOW_GEN_PROFID(hash, hdr) \
1756         (u64)(((u64)(hash) & ICE_FLOW_PROF_HASH_M) | \
1757               (((u64)(hdr) << ICE_FLOW_PROF_HDR_S) & ICE_FLOW_PROF_HDR_M))
1758
1759 /**
1760  * ice_add_rss_cfg_sync - add an RSS configuration
1761  * @hw: pointer to the hardware structure
1762  * @vsi_handle: software VSI handle
1763  * @hashed_flds: hash bit fields (ICE_FLOW_HASH_*) to configure
1764  * @addl_hdrs: protocol header fields
1765  *
1766  * Assumption: lock has already been acquired for RSS list
1767  */
1768 static enum ice_status
1769 ice_add_rss_cfg_sync(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds,
1770                      u32 addl_hdrs)
1771 {
1772         const enum ice_block blk = ICE_BLK_RSS;
1773         struct ice_flow_prof *prof = NULL;
1774         struct ice_flow_seg_info *segs;
1775         enum ice_status status = ICE_SUCCESS;
1776
1777         segs = (struct ice_flow_seg_info *)ice_malloc(hw, sizeof(*segs));
1778         if (!segs)
1779                 return ICE_ERR_NO_MEMORY;
1780
1781         /* Construct the packet segment info from the hashed fields */
1782         status = ice_flow_set_rss_seg_info(segs, hashed_flds, addl_hdrs);
1783         if (status)
1784                 goto exit;
1785
1786         /* Search for a flow profile that has matching headers, hash fields
1787          * and has the input VSI associated to it. If found, no further
1788          * operations required and exit.
1789          */
1790         prof = ice_flow_find_prof_conds(hw, blk, ICE_FLOW_RX, segs, 1,
1791                                         vsi_handle,
1792                                         ICE_FLOW_FIND_PROF_CHK_FLDS |
1793                                         ICE_FLOW_FIND_PROF_CHK_VSI);
1794         if (prof)
1795                 goto exit;
1796
1797         /* Check if a flow profile exists with the same protocol headers and
1798          * associated with the input VSI. If so disasscociate the VSI from
1799          * this profile. The VSI will be added to a new profile created with
1800          * the protocol header and new hash field configuration.
1801          */
1802         prof = ice_flow_find_prof_conds(hw, blk, ICE_FLOW_RX, segs, 1,
1803                                         vsi_handle, ICE_FLOW_FIND_PROF_CHK_VSI);
1804         if (prof) {
1805                 status = ice_flow_disassoc_prof(hw, blk, prof, vsi_handle);
1806                 if (!status)
1807                         ice_rem_rss_list(hw, vsi_handle, prof);
1808                 else
1809                         goto exit;
1810
1811                 /* Remove profile if it has no VSIs associated */
1812                 if (!ice_is_any_bit_set(prof->vsis, ICE_MAX_VSI)) {
1813                         status = ice_flow_rem_prof_sync(hw, blk, prof);
1814                         if (status)
1815                                 goto exit;
1816                 }
1817         }
1818
1819         /* Search for a profile that has same match fields only. If this
1820          * exists then associate the VSI to this profile.
1821          */
1822         prof = ice_flow_find_prof_conds(hw, blk, ICE_FLOW_RX, segs, 1,
1823                                         vsi_handle,
1824                                         ICE_FLOW_FIND_PROF_CHK_FLDS);
1825         if (prof) {
1826                 status = ice_flow_assoc_prof(hw, blk, prof, vsi_handle);
1827                 if (!status)
1828                         status = ice_add_rss_list(hw, vsi_handle, prof);
1829                 goto exit;
1830         }
1831
1832         /* Create a new flow profile with generated profile and packet
1833          * segment information.
1834          */
1835         status = ice_flow_add_prof(hw, blk, ICE_FLOW_RX,
1836                                    ICE_FLOW_GEN_PROFID(hashed_flds, segs->hdrs),
1837                                    segs, 1, NULL, 0, &prof);
1838         if (status)
1839                 goto exit;
1840
1841         status = ice_flow_assoc_prof(hw, blk, prof, vsi_handle);
1842         /* If association to a new flow profile failed then this profile can
1843          * be removed.
1844          */
1845         if (status) {
1846                 ice_flow_rem_prof_sync(hw, blk, prof);
1847                 goto exit;
1848         }
1849
1850         status = ice_add_rss_list(hw, vsi_handle, prof);
1851
1852 exit:
1853         ice_free(hw, segs);
1854         return status;
1855 }
1856
1857 /**
1858  * ice_add_rss_cfg - add an RSS configuration with specified hashed fields
1859  * @hw: pointer to the hardware structure
1860  * @vsi_handle: software VSI handle
1861  * @hashed_flds: hash bit fields (ICE_FLOW_HASH_*) to configure
1862  * @addl_hdrs: protocol header fields
1863  *
1864  * This function will generate a flow profile based on fields associated with
1865  * the input fields to hash on, the flow type and use the VSI number to add
1866  * a flow entry to the profile.
1867  */
1868 enum ice_status
1869 ice_add_rss_cfg(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds,
1870                 u32 addl_hdrs)
1871 {
1872         enum ice_status status;
1873
1874         if (hashed_flds == ICE_HASH_INVALID ||
1875             !ice_is_vsi_valid(hw, vsi_handle))
1876                 return ICE_ERR_PARAM;
1877
1878         ice_acquire_lock(&hw->rss_locks);
1879         status = ice_add_rss_cfg_sync(hw, vsi_handle, hashed_flds, addl_hdrs);
1880         ice_release_lock(&hw->rss_locks);
1881
1882         return status;
1883 }
1884
1885 /**
1886  * ice_rem_rss_cfg_sync - remove an existing RSS configuration
1887  * @hw: pointer to the hardware structure
1888  * @vsi_handle: software VSI handle
1889  * @hashed_flds: Packet hash types (ICE_FLOW_HASH_*) to remove
1890  * @addl_hdrs: Protocol header fields within a packet segment
1891  *
1892  * Assumption: lock has already been acquired for RSS list
1893  */
1894 static enum ice_status
1895 ice_rem_rss_cfg_sync(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds,
1896                      u32 addl_hdrs)
1897 {
1898         const enum ice_block blk = ICE_BLK_RSS;
1899         struct ice_flow_seg_info *segs;
1900         struct ice_flow_prof *prof;
1901         enum ice_status status;
1902
1903         segs = (struct ice_flow_seg_info *)ice_malloc(hw, sizeof(*segs));
1904         if (!segs)
1905                 return ICE_ERR_NO_MEMORY;
1906
1907         /* Construct the packet segment info from the hashed fields */
1908         status = ice_flow_set_rss_seg_info(segs, hashed_flds, addl_hdrs);
1909         if (status)
1910                 goto out;
1911
1912         prof = ice_flow_find_prof_conds(hw, blk, ICE_FLOW_RX, segs, 1,
1913                                         vsi_handle,
1914                                         ICE_FLOW_FIND_PROF_CHK_FLDS);
1915         if (!prof) {
1916                 status = ICE_ERR_DOES_NOT_EXIST;
1917                 goto out;
1918         }
1919
1920         status = ice_flow_disassoc_prof(hw, blk, prof, vsi_handle);
1921         if (status)
1922                 goto out;
1923
1924         /* Remove RSS configuration from VSI context before deleting
1925          * the flow profile.
1926          */
1927         ice_rem_rss_list(hw, vsi_handle, prof);
1928
1929         if (!ice_is_any_bit_set(prof->vsis, ICE_MAX_VSI))
1930                 status = ice_flow_rem_prof_sync(hw, blk, prof);
1931
1932 out:
1933         ice_free(hw, segs);
1934         return status;
1935 }
1936
1937 /* Mapping of AVF hash bit fields to an L3-L4 hash combination.
1938  * As the ice_flow_avf_hdr_field represent individual bit shifts in a hash,
1939  * convert its values to their appropriate flow L3, L4 values.
1940  */
1941 #define ICE_FLOW_AVF_RSS_IPV4_MASKS \
1942         (BIT_ULL(ICE_AVF_FLOW_FIELD_IPV4_OTHER) | \
1943          BIT_ULL(ICE_AVF_FLOW_FIELD_FRAG_IPV4))
1944 #define ICE_FLOW_AVF_RSS_TCP_IPV4_MASKS \
1945         (BIT_ULL(ICE_AVF_FLOW_FIELD_IPV4_TCP_SYN_NO_ACK) | \
1946          BIT_ULL(ICE_AVF_FLOW_FIELD_IPV4_TCP))
1947 #define ICE_FLOW_AVF_RSS_UDP_IPV4_MASKS \
1948         (BIT_ULL(ICE_AVF_FLOW_FIELD_UNICAST_IPV4_UDP) | \
1949          BIT_ULL(ICE_AVF_FLOW_FIELD_MULTICAST_IPV4_UDP) | \
1950          BIT_ULL(ICE_AVF_FLOW_FIELD_IPV4_UDP))
1951 #define ICE_FLOW_AVF_RSS_ALL_IPV4_MASKS \
1952         (ICE_FLOW_AVF_RSS_TCP_IPV4_MASKS | ICE_FLOW_AVF_RSS_UDP_IPV4_MASKS | \
1953          ICE_FLOW_AVF_RSS_IPV4_MASKS | BIT_ULL(ICE_AVF_FLOW_FIELD_IPV4_SCTP))
1954
1955 #define ICE_FLOW_AVF_RSS_IPV6_MASKS \
1956         (BIT_ULL(ICE_AVF_FLOW_FIELD_IPV6_OTHER) | \
1957          BIT_ULL(ICE_AVF_FLOW_FIELD_FRAG_IPV6))
1958 #define ICE_FLOW_AVF_RSS_UDP_IPV6_MASKS \
1959         (BIT_ULL(ICE_AVF_FLOW_FIELD_UNICAST_IPV6_UDP) | \
1960          BIT_ULL(ICE_AVF_FLOW_FIELD_MULTICAST_IPV6_UDP) | \
1961          BIT_ULL(ICE_AVF_FLOW_FIELD_IPV6_UDP))
1962 #define ICE_FLOW_AVF_RSS_TCP_IPV6_MASKS \
1963         (BIT_ULL(ICE_AVF_FLOW_FIELD_IPV6_TCP_SYN_NO_ACK) | \
1964          BIT_ULL(ICE_AVF_FLOW_FIELD_IPV6_TCP))
1965 #define ICE_FLOW_AVF_RSS_ALL_IPV6_MASKS \
1966         (ICE_FLOW_AVF_RSS_TCP_IPV6_MASKS | ICE_FLOW_AVF_RSS_UDP_IPV6_MASKS | \
1967          ICE_FLOW_AVF_RSS_IPV6_MASKS | BIT_ULL(ICE_AVF_FLOW_FIELD_IPV6_SCTP))
1968
1969 #define ICE_FLOW_MAX_CFG        10
1970
1971 /**
1972  * ice_add_avf_rss_cfg - add an RSS configuration for AVF driver
1973  * @hw: pointer to the hardware structure
1974  * @vsi_handle: software VSI handle
1975  * @avf_hash: hash bit fields (ICE_AVF_FLOW_FIELD_*) to configure
1976  *
1977  * This function will take the hash bitmap provided by the AVF driver via a
1978  * message, convert it to ICE-compatible values, and configure RSS flow
1979  * profiles.
1980  */
1981 enum ice_status
1982 ice_add_avf_rss_cfg(struct ice_hw *hw, u16 vsi_handle, u64 avf_hash)
1983 {
1984         enum ice_status status = ICE_SUCCESS;
1985         u64 hash_flds;
1986
1987         if (avf_hash == ICE_AVF_FLOW_FIELD_INVALID ||
1988             !ice_is_vsi_valid(hw, vsi_handle))
1989                 return ICE_ERR_PARAM;
1990
1991         /* Make sure no unsupported bits are specified */
1992         if (avf_hash & ~(ICE_FLOW_AVF_RSS_ALL_IPV4_MASKS |
1993                          ICE_FLOW_AVF_RSS_ALL_IPV6_MASKS))
1994                 return ICE_ERR_CFG;
1995
1996         hash_flds = avf_hash;
1997
1998         /* Always create an L3 RSS configuration for any L4 RSS configuration */
1999         if (hash_flds & ICE_FLOW_AVF_RSS_ALL_IPV4_MASKS)
2000                 hash_flds |= ICE_FLOW_AVF_RSS_IPV4_MASKS;
2001
2002         if (hash_flds & ICE_FLOW_AVF_RSS_ALL_IPV6_MASKS)
2003                 hash_flds |= ICE_FLOW_AVF_RSS_IPV6_MASKS;
2004
2005         /* Create the corresponding RSS configuration for each valid hash bit */
2006         while (hash_flds) {
2007                 u64 rss_hash = ICE_HASH_INVALID;
2008
2009                 if (hash_flds & ICE_FLOW_AVF_RSS_ALL_IPV4_MASKS) {
2010                         if (hash_flds & ICE_FLOW_AVF_RSS_IPV4_MASKS) {
2011                                 rss_hash = ICE_FLOW_HASH_IPV4;
2012                                 hash_flds &= ~ICE_FLOW_AVF_RSS_IPV4_MASKS;
2013                         } else if (hash_flds &
2014                                    ICE_FLOW_AVF_RSS_TCP_IPV4_MASKS) {
2015                                 rss_hash = ICE_FLOW_HASH_IPV4 |
2016                                         ICE_FLOW_HASH_TCP_PORT;
2017                                 hash_flds &= ~ICE_FLOW_AVF_RSS_TCP_IPV4_MASKS;
2018                         } else if (hash_flds &
2019                                    ICE_FLOW_AVF_RSS_UDP_IPV4_MASKS) {
2020                                 rss_hash = ICE_FLOW_HASH_IPV4 |
2021                                         ICE_FLOW_HASH_UDP_PORT;
2022                                 hash_flds &= ~ICE_FLOW_AVF_RSS_UDP_IPV4_MASKS;
2023                         } else if (hash_flds &
2024                                    BIT_ULL(ICE_AVF_FLOW_FIELD_IPV4_SCTP)) {
2025                                 rss_hash = ICE_FLOW_HASH_IPV4 |
2026                                         ICE_FLOW_HASH_SCTP_PORT;
2027                                 hash_flds &=
2028                                         ~BIT_ULL(ICE_AVF_FLOW_FIELD_IPV4_SCTP);
2029                         }
2030                 } else if (hash_flds & ICE_FLOW_AVF_RSS_ALL_IPV6_MASKS) {
2031                         if (hash_flds & ICE_FLOW_AVF_RSS_IPV6_MASKS) {
2032                                 rss_hash = ICE_FLOW_HASH_IPV6;
2033                                 hash_flds &= ~ICE_FLOW_AVF_RSS_IPV6_MASKS;
2034                         } else if (hash_flds &
2035                                    ICE_FLOW_AVF_RSS_TCP_IPV6_MASKS) {
2036                                 rss_hash = ICE_FLOW_HASH_IPV6 |
2037                                         ICE_FLOW_HASH_TCP_PORT;
2038                                 hash_flds &= ~ICE_FLOW_AVF_RSS_TCP_IPV6_MASKS;
2039                         } else if (hash_flds &
2040                                    ICE_FLOW_AVF_RSS_UDP_IPV6_MASKS) {
2041                                 rss_hash = ICE_FLOW_HASH_IPV6 |
2042                                         ICE_FLOW_HASH_UDP_PORT;
2043                                 hash_flds &= ~ICE_FLOW_AVF_RSS_UDP_IPV6_MASKS;
2044                         } else if (hash_flds &
2045                                    BIT_ULL(ICE_AVF_FLOW_FIELD_IPV6_SCTP)) {
2046                                 rss_hash = ICE_FLOW_HASH_IPV6 |
2047                                         ICE_FLOW_HASH_SCTP_PORT;
2048                                 hash_flds &=
2049                                         ~BIT_ULL(ICE_AVF_FLOW_FIELD_IPV6_SCTP);
2050                         }
2051                 }
2052
2053                 if (rss_hash == ICE_HASH_INVALID)
2054                         return ICE_ERR_OUT_OF_RANGE;
2055
2056                 status = ice_add_rss_cfg(hw, vsi_handle, rss_hash,
2057                                          ICE_FLOW_SEG_HDR_NONE);
2058                 if (status)
2059                         break;
2060         }
2061
2062         return status;
2063 }
2064
2065 /**
2066  * ice_rem_rss_cfg - remove an existing RSS config with matching hashed fields
2067  * @hw: pointer to the hardware structure
2068  * @vsi_handle: software VSI handle
2069  * @hashed_flds: Packet hash types (ICE_FLOW_HASH_*) to remove
2070  * @addl_hdrs: Protocol header fields within a packet segment
2071  *
2072  * This function will lookup the flow profile based on the input
2073  * hash field bitmap, iterate through the profile entry list of
2074  * that profile and find entry associated with input VSI to be
2075  * removed. Calls are made to underlying flow apis which will in
2076  * turn build or update buffers for RSS XLT1 section.
2077  */
2078 enum ice_status
2079 ice_rem_rss_cfg(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds,
2080                 u32 addl_hdrs)
2081 {
2082         enum ice_status status;
2083
2084         if (hashed_flds == ICE_HASH_INVALID ||
2085             !ice_is_vsi_valid(hw, vsi_handle))
2086                 return ICE_ERR_PARAM;
2087
2088         ice_acquire_lock(&hw->rss_locks);
2089         status = ice_rem_rss_cfg_sync(hw, vsi_handle, hashed_flds, addl_hdrs);
2090         ice_release_lock(&hw->rss_locks);
2091
2092         return status;
2093 }
2094
2095 /**
2096  * ice_replay_rss_cfg - replay RSS configurations associated with VSI
2097  * @hw: pointer to the hardware structure
2098  * @vsi_handle: software VSI handle
2099  */
2100 enum ice_status ice_replay_rss_cfg(struct ice_hw *hw, u16 vsi_handle)
2101 {
2102         enum ice_status status = ICE_SUCCESS;
2103         struct ice_rss_cfg *r;
2104
2105         if (!ice_is_vsi_valid(hw, vsi_handle))
2106                 return ICE_ERR_PARAM;
2107
2108         ice_acquire_lock(&hw->rss_locks);
2109         LIST_FOR_EACH_ENTRY(r, &hw->rss_list_head,
2110                             ice_rss_cfg, l_entry) {
2111                 if (ice_is_bit_set(r->vsis, vsi_handle)) {
2112                         status = ice_add_rss_cfg_sync(hw, vsi_handle,
2113                                                       r->hashed_flds,
2114                                                       r->packet_hdr);
2115                         if (status)
2116                                 break;
2117                 }
2118         }
2119         ice_release_lock(&hw->rss_locks);
2120
2121         return status;
2122 }
2123
2124 /**
2125  * ice_get_rss_cfg - returns hashed fields for the given header types
2126  * @hw: pointer to the hardware structure
2127  * @vsi_handle: software VSI handle
2128  * @hdrs: protocol header type
2129  *
2130  * This function will return the match fields of the first instance of flow
2131  * profile having the given header types and containing input VSI
2132  */
2133 u64 ice_get_rss_cfg(struct ice_hw *hw, u16 vsi_handle, u32 hdrs)
2134 {
2135         struct ice_rss_cfg *r, *rss_cfg = NULL;
2136
2137         /* verify if the protocol header is non zero and VSI is valid */
2138         if (hdrs == ICE_FLOW_SEG_HDR_NONE || !ice_is_vsi_valid(hw, vsi_handle))
2139                 return ICE_HASH_INVALID;
2140
2141         ice_acquire_lock(&hw->rss_locks);
2142         LIST_FOR_EACH_ENTRY(r, &hw->rss_list_head,
2143                             ice_rss_cfg, l_entry)
2144                 if (ice_is_bit_set(r->vsis, vsi_handle) &&
2145                     r->packet_hdr == hdrs) {
2146                         rss_cfg = r;
2147                         break;
2148                 }
2149         ice_release_lock(&hw->rss_locks);
2150
2151         return rss_cfg ? rss_cfg->hashed_flds : ICE_HASH_INVALID;
2152 }