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