sys/dev/ice/ice_flow.c

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