drivers/net/ice/base/ice_flow.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2001-2020 Intel Corporation
   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_IPV6_PRE32_ADDR 4
  14 #define ICE_FLOW_FLD_SZ_IPV6_PRE48_ADDR 6
  15 #define ICE_FLOW_FLD_SZ_IPV6_PRE64_ADDR 8
  16 #define ICE_FLOW_FLD_SZ_IP_DSCP         1
  17 #define ICE_FLOW_FLD_SZ_IP_TTL          1
  18 #define ICE_FLOW_FLD_SZ_IP_PROT         1
  19 #define ICE_FLOW_FLD_SZ_PORT            2
  20 #define ICE_FLOW_FLD_SZ_TCP_FLAGS       1
  21 #define ICE_FLOW_FLD_SZ_ICMP_TYPE       1
  22 #define ICE_FLOW_FLD_SZ_ICMP_CODE       1
  23 #define ICE_FLOW_FLD_SZ_ARP_OPER        2
  24 #define ICE_FLOW_FLD_SZ_GRE_KEYID       4
  25 #define ICE_FLOW_FLD_SZ_GTP_TEID        4
  26 #define ICE_FLOW_FLD_SZ_GTP_QFI         2
  27 #define ICE_FLOW_FLD_SZ_PPPOE_SESS_ID   2
  28 #define ICE_FLOW_FLD_SZ_PFCP_SEID 8
  29 #define ICE_FLOW_FLD_SZ_L2TPV3_SESS_ID  4
  30 #define ICE_FLOW_FLD_SZ_ESP_SPI 4
  31 #define ICE_FLOW_FLD_SZ_AH_SPI  4
  32 #define ICE_FLOW_FLD_SZ_NAT_T_ESP_SPI   4
  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, 0, ICE_FLOW_FLD_SZ_ETH_TYPE),
  70         /* IPv4 / IPv6 */
  71         /* ICE_FLOW_FIELD_IDX_IPV4_DSCP */
  72         ICE_FLOW_FLD_INFO_MSK(ICE_FLOW_SEG_HDR_IPV4, 0, ICE_FLOW_FLD_SZ_IP_DSCP,
  73                               0x00fc),
  74         /* ICE_FLOW_FIELD_IDX_IPV6_DSCP */
  75         ICE_FLOW_FLD_INFO_MSK(ICE_FLOW_SEG_HDR_IPV6, 0, ICE_FLOW_FLD_SZ_IP_DSCP,
  76                               0x0ff0),
  77         /* ICE_FLOW_FIELD_IDX_IPV4_TTL */
  78         ICE_FLOW_FLD_INFO_MSK(ICE_FLOW_SEG_HDR_NONE, 8,
  79                               ICE_FLOW_FLD_SZ_IP_TTL, 0xff00),
  80         /* ICE_FLOW_FIELD_IDX_IPV4_PROT */
  81         ICE_FLOW_FLD_INFO_MSK(ICE_FLOW_SEG_HDR_NONE, 8,
  82                               ICE_FLOW_FLD_SZ_IP_PROT, 0x00ff),
  83         /* ICE_FLOW_FIELD_IDX_IPV6_TTL */
  84         ICE_FLOW_FLD_INFO_MSK(ICE_FLOW_SEG_HDR_NONE, 6,
  85                               ICE_FLOW_FLD_SZ_IP_TTL, 0x00ff),
  86         /* ICE_FLOW_FIELD_IDX_IPV6_PROT */
  87         ICE_FLOW_FLD_INFO_MSK(ICE_FLOW_SEG_HDR_NONE, 6,
  88                               ICE_FLOW_FLD_SZ_IP_PROT, 0xff00),
  89         /* ICE_FLOW_FIELD_IDX_IPV4_SA */
  90         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_IPV4, 12, ICE_FLOW_FLD_SZ_IPV4_ADDR),
  91         /* ICE_FLOW_FIELD_IDX_IPV4_DA */
  92         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_IPV4, 16, ICE_FLOW_FLD_SZ_IPV4_ADDR),
  93         /* ICE_FLOW_FIELD_IDX_IPV6_SA */
  94         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_IPV6, 8, ICE_FLOW_FLD_SZ_IPV6_ADDR),
  95         /* ICE_FLOW_FIELD_IDX_IPV6_DA */
  96         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_IPV6, 24, ICE_FLOW_FLD_SZ_IPV6_ADDR),
  97         /* ICE_FLOW_FIELD_IDX_IPV6_PRE32_SA */
  98         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_IPV6, 8,
  99                           ICE_FLOW_FLD_SZ_IPV6_PRE32_ADDR),
 100         /* ICE_FLOW_FIELD_IDX_IPV6_PRE32_DA */
 101         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_IPV6, 24,
 102                           ICE_FLOW_FLD_SZ_IPV6_PRE32_ADDR),
 103         /* ICE_FLOW_FIELD_IDX_IPV6_PRE48_SA */
 104         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_IPV6, 8,
 105                           ICE_FLOW_FLD_SZ_IPV6_PRE48_ADDR),
 106         /* ICE_FLOW_FIELD_IDX_IPV6_PRE48_DA */
 107         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_IPV6, 24,
 108                           ICE_FLOW_FLD_SZ_IPV6_PRE48_ADDR),
 109         /* ICE_FLOW_FIELD_IDX_IPV6_PRE64_SA */
 110         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_IPV6, 8,
 111                           ICE_FLOW_FLD_SZ_IPV6_PRE64_ADDR),
 112         /* ICE_FLOW_FIELD_IDX_IPV6_PRE64_DA */
 113         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_IPV6, 24,
 114                           ICE_FLOW_FLD_SZ_IPV6_PRE64_ADDR),
 115         /* Transport */
 116         /* ICE_FLOW_FIELD_IDX_TCP_SRC_PORT */
 117         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_TCP, 0, ICE_FLOW_FLD_SZ_PORT),
 118         /* ICE_FLOW_FIELD_IDX_TCP_DST_PORT */
 119         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_TCP, 2, ICE_FLOW_FLD_SZ_PORT),
 120         /* ICE_FLOW_FIELD_IDX_UDP_SRC_PORT */
 121         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_UDP, 0, ICE_FLOW_FLD_SZ_PORT),
 122         /* ICE_FLOW_FIELD_IDX_UDP_DST_PORT */
 123         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_UDP, 2, ICE_FLOW_FLD_SZ_PORT),
 124         /* ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT */
 125         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_SCTP, 0, ICE_FLOW_FLD_SZ_PORT),
 126         /* ICE_FLOW_FIELD_IDX_SCTP_DST_PORT */
 127         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_SCTP, 2, ICE_FLOW_FLD_SZ_PORT),
 128         /* ICE_FLOW_FIELD_IDX_TCP_FLAGS */
 129         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_TCP, 13, ICE_FLOW_FLD_SZ_TCP_FLAGS),
 130         /* ARP */
 131         /* ICE_FLOW_FIELD_IDX_ARP_SIP */
 132         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_ARP, 14, ICE_FLOW_FLD_SZ_IPV4_ADDR),
 133         /* ICE_FLOW_FIELD_IDX_ARP_DIP */
 134         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_ARP, 24, ICE_FLOW_FLD_SZ_IPV4_ADDR),
 135         /* ICE_FLOW_FIELD_IDX_ARP_SHA */
 136         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_ARP, 8, ETH_ALEN),
 137         /* ICE_FLOW_FIELD_IDX_ARP_DHA */
 138         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_ARP, 18, ETH_ALEN),
 139         /* ICE_FLOW_FIELD_IDX_ARP_OP */
 140         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_ARP, 6, ICE_FLOW_FLD_SZ_ARP_OPER),
 141         /* ICMP */
 142         /* ICE_FLOW_FIELD_IDX_ICMP_TYPE */
 143         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_ICMP, 0, ICE_FLOW_FLD_SZ_ICMP_TYPE),
 144         /* ICE_FLOW_FIELD_IDX_ICMP_CODE */
 145         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_ICMP, 1, ICE_FLOW_FLD_SZ_ICMP_CODE),
 146         /* GRE */
 147         /* ICE_FLOW_FIELD_IDX_GRE_KEYID */
 148         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_GRE, 12, ICE_FLOW_FLD_SZ_GRE_KEYID),
 149         /* GTP */
 150         /* ICE_FLOW_FIELD_IDX_GTPC_TEID */
 151         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_GTPC_TEID, 12,
 152                           ICE_FLOW_FLD_SZ_GTP_TEID),
 153         /* ICE_FLOW_FIELD_IDX_GTPU_IP_TEID */
 154         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_GTPU_IP, 12,
 155                           ICE_FLOW_FLD_SZ_GTP_TEID),
 156         /* ICE_FLOW_FIELD_IDX_GTPU_EH_TEID */
 157         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_GTPU_EH, 12,
 158                           ICE_FLOW_FLD_SZ_GTP_TEID),
 159         /* ICE_FLOW_FIELD_IDX_GTPU_EH_QFI */
 160         ICE_FLOW_FLD_INFO_MSK(ICE_FLOW_SEG_HDR_GTPU_EH, 22,
 161                               ICE_FLOW_FLD_SZ_GTP_QFI, 0x3f00),
 162         /* ICE_FLOW_FIELD_IDX_GTPU_UP_TEID */
 163         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_GTPU_UP, 12,
 164                           ICE_FLOW_FLD_SZ_GTP_TEID),
 165         /* ICE_FLOW_FIELD_IDX_GTPU_DWN_TEID */
 166         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_GTPU_DWN, 12,
 167                           ICE_FLOW_FLD_SZ_GTP_TEID),
 168         /* PPPOE */
 169         /* ICE_FLOW_FIELD_IDX_PPPOE_SESS_ID */
 170         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_PPPOE, 2,
 171                           ICE_FLOW_FLD_SZ_PPPOE_SESS_ID),
 172         /* PFCP */
 173         /* ICE_FLOW_FIELD_IDX_PFCP_SEID */
 174         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_PFCP_SESSION, 12,
 175                           ICE_FLOW_FLD_SZ_PFCP_SEID),
 176         /* L2TPV3 */
 177         /* ICE_FLOW_FIELD_IDX_L2TPV3_SESS_ID */
 178         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_L2TPV3, 0,
 179                           ICE_FLOW_FLD_SZ_L2TPV3_SESS_ID),
 180         /* ESP */
 181         /* ICE_FLOW_FIELD_IDX_ESP_SPI */
 182         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_ESP, 0,
 183                           ICE_FLOW_FLD_SZ_ESP_SPI),
 184         /* AH */
 185         /* ICE_FLOW_FIELD_IDX_AH_SPI */
 186         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_AH, 4,
 187                           ICE_FLOW_FLD_SZ_AH_SPI),
 188         /* NAT_T_ESP */
 189         /* ICE_FLOW_FIELD_IDX_NAT_T_ESP_SPI */
 190         ICE_FLOW_FLD_INFO(ICE_FLOW_SEG_HDR_NAT_T_ESP, 8,
 191                           ICE_FLOW_FLD_SZ_NAT_T_ESP_SPI),
 192 };
 193
 194 /* Bitmaps indicating relevant packet types for a particular protocol header
 195  *
 196  * Packet types for packets with an Outer/First/Single MAC header
 197  */
 198 static const u32 ice_ptypes_mac_ofos[] = {
 199         0xFDC00846, 0xBFBF7F7E, 0xF70001DF, 0xFEFDFDFB,
 200         0x0000077E, 0x00000000, 0x00000000, 0x00000000,
 201         0x00400000, 0x03FFF000, 0x7FFFFFE0, 0x00000000,
 202         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 203         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 204         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 205         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 206         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 207 };
 208
 209 /* Packet types for packets with an Innermost/Last MAC VLAN header */
 210 static const u32 ice_ptypes_macvlan_il[] = {
 211         0x00000000, 0xBC000000, 0x000001DF, 0xF0000000,
 212         0x0000077E, 0x00000000, 0x00000000, 0x00000000,
 213         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 214         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 215         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 216         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 217         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 218         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 219 };
 220
 221 /* Packet types for packets with an Outer/First/Single IPv4 header, does NOT
 222  * include IPV4 other PTYPEs
 223  */
 224 static const u32 ice_ptypes_ipv4_ofos[] = {
 225         0x1DC00000, 0x04000800, 0x00000000, 0x00000000,
 226         0x00000000, 0x00000155, 0x00000000, 0x00000000,
 227         0x00000000, 0x000FC000, 0x000002A0, 0x00000000,
 228         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 229         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 230         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 231         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 232         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 233 };
 234
 235 /* Packet types for packets with an Outer/First/Single IPv4 header, includes
 236  * IPV4 other PTYPEs
 237  */
 238 static const u32 ice_ptypes_ipv4_ofos_all[] = {
 239         0x1DC00000, 0x04000800, 0x00000000, 0x00000000,
 240         0x00000000, 0x00000155, 0x00000000, 0x00000000,
 241         0x00000000, 0x000FC000, 0x83E0FAA0, 0x00000101,
 242         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 243         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 244         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 245         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 246         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 247 };
 248
 249 /* Packet types for packets with an Innermost/Last IPv4 header */
 250 static const u32 ice_ptypes_ipv4_il[] = {
 251         0xE0000000, 0xB807700E, 0x80000003, 0xE01DC03B,
 252         0x0000000E, 0x00000000, 0x00000000, 0x00000000,
 253         0x00000000, 0x00000000, 0x001FF800, 0x00000000,
 254         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 255         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 256         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 257         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 258         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 259 };
 260
 261 /* Packet types for packets with an Outer/First/Single IPv6 header, does NOT
 262  * include IVP6 other PTYPEs
 263  */
 264 static const u32 ice_ptypes_ipv6_ofos[] = {
 265         0x00000000, 0x00000000, 0x77000000, 0x10002000,
 266         0x00000000, 0x000002AA, 0x00000000, 0x00000000,
 267         0x00000000, 0x03F00000, 0x00000540, 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 };
 274
 275 /* Packet types for packets with an Outer/First/Single IPv6 header, includes
 276  * IPV6 other PTYPEs
 277  */
 278 static const u32 ice_ptypes_ipv6_ofos_all[] = {
 279         0x00000000, 0x00000000, 0x77000000, 0x10002000,
 280         0x00000000, 0x000002AA, 0x00000000, 0x00000000,
 281         0x00000000, 0x03F00000, 0x7C1F0540, 0x00000206,
 282         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 283         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 284         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 285         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 286         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 287 };
 288
 289 /* Packet types for packets with an Innermost/Last IPv6 header */
 290 static const u32 ice_ptypes_ipv6_il[] = {
 291         0x00000000, 0x03B80770, 0x000001DC, 0x0EE00000,
 292         0x00000770, 0x00000000, 0x00000000, 0x00000000,
 293         0x00000000, 0x00000000, 0x7FE00000, 0x00000000,
 294         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 295         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 296         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 297         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 298         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 299 };
 300
 301 /* Packet types for packets with an Outer/First/Single IPv4 header - no L4 */
 302 static const u32 ice_ipv4_ofos_no_l4[] = {
 303         0x10C00000, 0x04000800, 0x00000000, 0x00000000,
 304         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 305         0x00000000, 0x000cc000, 0x000002A0, 0x00000000,
 306         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 307         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 308         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 309         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 310         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 311 };
 312
 313 /* Packet types for packets with an Innermost/Last IPv4 header - no L4 */
 314 static const u32 ice_ipv4_il_no_l4[] = {
 315         0x60000000, 0x18043008, 0x80000002, 0x6010c021,
 316         0x00000008, 0x00000000, 0x00000000, 0x00000000,
 317         0x00000000, 0x00000000, 0x00139800, 0x00000000,
 318         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 319         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 320         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 321         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 322         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 323 };
 324
 325 /* Packet types for packets with an Outer/First/Single IPv6 header - no L4 */
 326 static const u32 ice_ipv6_ofos_no_l4[] = {
 327         0x00000000, 0x00000000, 0x43000000, 0x10002000,
 328         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 329         0x00000000, 0x02300000, 0x00000540, 0x00000000,
 330         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 331         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 332         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 333         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 334         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 335 };
 336
 337 /* Packet types for packets with an Innermost/Last IPv6 header - no L4 */
 338 static const u32 ice_ipv6_il_no_l4[] = {
 339         0x00000000, 0x02180430, 0x0000010c, 0x086010c0,
 340         0x00000430, 0x00000000, 0x00000000, 0x00000000,
 341         0x00000000, 0x00000000, 0x4e600000, 0x00000000,
 342         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 343         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 344         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 345         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 346         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 347 };
 348
 349 /* Packet types for packets with an Outermost/First ARP header */
 350 static const u32 ice_ptypes_arp_of[] = {
 351         0x00000800, 0x00000000, 0x00000000, 0x00000000,
 352         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 353         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 354         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 355         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 356         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 357         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 358         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 359 };
 360
 361 /* UDP Packet types for non-tunneled packets or tunneled
 362  * packets with inner UDP.
 363  */
 364 static const u32 ice_ptypes_udp_il[] = {
 365         0x81000000, 0x20204040, 0x04000010, 0x80810102,
 366         0x00000040, 0x00000000, 0x00000000, 0x00000000,
 367         0x00000000, 0x00410000, 0x90842000, 0x00000007,
 368         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 369         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 370         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 371         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 372         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 373 };
 374
 375 /* Packet types for packets with an Innermost/Last TCP header */
 376 static const u32 ice_ptypes_tcp_il[] = {
 377         0x04000000, 0x80810102, 0x10000040, 0x02040408,
 378         0x00000102, 0x00000000, 0x00000000, 0x00000000,
 379         0x00000000, 0x00820000, 0x21084000, 0x00000000,
 380         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 381         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 382         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 383         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 384         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 385 };
 386
 387 /* Packet types for packets with an Innermost/Last SCTP header */
 388 static const u32 ice_ptypes_sctp_il[] = {
 389         0x08000000, 0x01020204, 0x20000081, 0x04080810,
 390         0x00000204, 0x00000000, 0x00000000, 0x00000000,
 391         0x00000000, 0x01040000, 0x00000000, 0x00000000,
 392         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 393         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 394         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 395         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 396         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 397 };
 398
 399 /* Packet types for packets with an Outermost/First ICMP header */
 400 static const u32 ice_ptypes_icmp_of[] = {
 401         0x10000000, 0x00000000, 0x00000000, 0x00000000,
 402         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 403         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 404         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 405         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 406         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 407         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 408         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 409 };
 410
 411 /* Packet types for packets with an Innermost/Last ICMP header */
 412 static const u32 ice_ptypes_icmp_il[] = {
 413         0x00000000, 0x02040408, 0x40000102, 0x08101020,
 414         0x00000408, 0x00000000, 0x00000000, 0x00000000,
 415         0x00000000, 0x00000000, 0x42108000, 0x00000000,
 416         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 417         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 418         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 419         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 420         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 421 };
 422
 423 /* Packet types for packets with an Outermost/First GRE header */
 424 static const u32 ice_ptypes_gre_of[] = {
 425         0x00000000, 0xBFBF7800, 0x000001DF, 0xFEFDE000,
 426         0x0000017E, 0x00000000, 0x00000000, 0x00000000,
 427         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 428         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 429         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 430         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 431         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 432         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 433 };
 434
 435 /* Packet types for packets with an Innermost/Last MAC header */
 436 static const u32 ice_ptypes_mac_il[] = {
 437         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 438         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 439         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 440         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 441         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 442         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 443         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 444         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 445 };
 446
 447 /* Packet types for GTPC */
 448 static const u32 ice_ptypes_gtpc[] = {
 449         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 450         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 451         0x00000000, 0x00000000, 0x000001E0, 0x00000000,
 452         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 453         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 454         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 455         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 456         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 457 };
 458
 459 /* Packet types for GTPC with TEID */
 460 static const u32 ice_ptypes_gtpc_tid[] = {
 461         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 462         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 463         0x00000000, 0x00000000, 0x00000060, 0x00000000,
 464         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 465         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 466         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 467         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 468         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 469 };
 470
 471 /* Packet types for GTPU */
 472 static const struct ice_ptype_attributes ice_attr_gtpu_session[] = {
 473         { ICE_MAC_IPV4_GTPU_IPV4_FRAG,    ICE_PTYPE_ATTR_GTP_SESSION },
 474         { ICE_MAC_IPV4_GTPU_IPV4_PAY,     ICE_PTYPE_ATTR_GTP_SESSION },
 475         { ICE_MAC_IPV4_GTPU_IPV4_UDP_PAY, ICE_PTYPE_ATTR_GTP_SESSION },
 476         { ICE_MAC_IPV4_GTPU_IPV4_TCP,     ICE_PTYPE_ATTR_GTP_SESSION },
 477         { ICE_MAC_IPV4_GTPU_IPV4_ICMP,    ICE_PTYPE_ATTR_GTP_SESSION },
 478         { ICE_MAC_IPV6_GTPU_IPV4_FRAG,    ICE_PTYPE_ATTR_GTP_SESSION },
 479         { ICE_MAC_IPV6_GTPU_IPV4_PAY,     ICE_PTYPE_ATTR_GTP_SESSION },
 480         { ICE_MAC_IPV6_GTPU_IPV4_UDP_PAY, ICE_PTYPE_ATTR_GTP_SESSION },
 481         { ICE_MAC_IPV6_GTPU_IPV4_TCP,     ICE_PTYPE_ATTR_GTP_SESSION },
 482         { ICE_MAC_IPV6_GTPU_IPV4_ICMP,    ICE_PTYPE_ATTR_GTP_SESSION },
 483         { ICE_MAC_IPV4_GTPU_IPV6_FRAG,    ICE_PTYPE_ATTR_GTP_SESSION },
 484         { ICE_MAC_IPV4_GTPU_IPV6_PAY,     ICE_PTYPE_ATTR_GTP_SESSION },
 485         { ICE_MAC_IPV4_GTPU_IPV6_UDP_PAY, ICE_PTYPE_ATTR_GTP_SESSION },
 486         { ICE_MAC_IPV4_GTPU_IPV6_TCP,     ICE_PTYPE_ATTR_GTP_SESSION },
 487         { ICE_MAC_IPV4_GTPU_IPV6_ICMPV6,  ICE_PTYPE_ATTR_GTP_SESSION },
 488         { ICE_MAC_IPV6_GTPU_IPV6_FRAG,    ICE_PTYPE_ATTR_GTP_SESSION },
 489         { ICE_MAC_IPV6_GTPU_IPV6_PAY,     ICE_PTYPE_ATTR_GTP_SESSION },
 490         { ICE_MAC_IPV6_GTPU_IPV6_UDP_PAY, ICE_PTYPE_ATTR_GTP_SESSION },
 491         { ICE_MAC_IPV6_GTPU_IPV6_TCP,     ICE_PTYPE_ATTR_GTP_SESSION },
 492         { ICE_MAC_IPV6_GTPU_IPV6_ICMPV6,  ICE_PTYPE_ATTR_GTP_SESSION },
 493 };
 494
 495 static const struct ice_ptype_attributes ice_attr_gtpu_eh[] = {
 496         { ICE_MAC_IPV4_GTPU_IPV4_FRAG,    ICE_PTYPE_ATTR_GTP_PDU_EH },
 497         { ICE_MAC_IPV4_GTPU_IPV4_PAY,     ICE_PTYPE_ATTR_GTP_PDU_EH },
 498         { ICE_MAC_IPV4_GTPU_IPV4_UDP_PAY, ICE_PTYPE_ATTR_GTP_PDU_EH },
 499         { ICE_MAC_IPV4_GTPU_IPV4_TCP,     ICE_PTYPE_ATTR_GTP_PDU_EH },
 500         { ICE_MAC_IPV4_GTPU_IPV4_ICMP,    ICE_PTYPE_ATTR_GTP_PDU_EH },
 501         { ICE_MAC_IPV6_GTPU_IPV4_FRAG,    ICE_PTYPE_ATTR_GTP_PDU_EH },
 502         { ICE_MAC_IPV6_GTPU_IPV4_PAY,     ICE_PTYPE_ATTR_GTP_PDU_EH },
 503         { ICE_MAC_IPV6_GTPU_IPV4_UDP_PAY, ICE_PTYPE_ATTR_GTP_PDU_EH },
 504         { ICE_MAC_IPV6_GTPU_IPV4_TCP,     ICE_PTYPE_ATTR_GTP_PDU_EH },
 505         { ICE_MAC_IPV6_GTPU_IPV4_ICMP,    ICE_PTYPE_ATTR_GTP_PDU_EH },
 506         { ICE_MAC_IPV4_GTPU_IPV6_FRAG,    ICE_PTYPE_ATTR_GTP_PDU_EH },
 507         { ICE_MAC_IPV4_GTPU_IPV6_PAY,     ICE_PTYPE_ATTR_GTP_PDU_EH },
 508         { ICE_MAC_IPV4_GTPU_IPV6_UDP_PAY, ICE_PTYPE_ATTR_GTP_PDU_EH },
 509         { ICE_MAC_IPV4_GTPU_IPV6_TCP,     ICE_PTYPE_ATTR_GTP_PDU_EH },
 510         { ICE_MAC_IPV4_GTPU_IPV6_ICMPV6,  ICE_PTYPE_ATTR_GTP_PDU_EH },
 511         { ICE_MAC_IPV6_GTPU_IPV6_FRAG,    ICE_PTYPE_ATTR_GTP_PDU_EH },
 512         { ICE_MAC_IPV6_GTPU_IPV6_PAY,     ICE_PTYPE_ATTR_GTP_PDU_EH },
 513         { ICE_MAC_IPV6_GTPU_IPV6_UDP_PAY, ICE_PTYPE_ATTR_GTP_PDU_EH },
 514         { ICE_MAC_IPV6_GTPU_IPV6_TCP,     ICE_PTYPE_ATTR_GTP_PDU_EH },
 515         { ICE_MAC_IPV6_GTPU_IPV6_ICMPV6,  ICE_PTYPE_ATTR_GTP_PDU_EH },
 516 };
 517
 518 static const struct ice_ptype_attributes ice_attr_gtpu_down[] = {
 519         { ICE_MAC_IPV4_GTPU_IPV4_FRAG,    ICE_PTYPE_ATTR_GTP_DOWNLINK },
 520         { ICE_MAC_IPV4_GTPU_IPV4_PAY,     ICE_PTYPE_ATTR_GTP_DOWNLINK },
 521         { ICE_MAC_IPV4_GTPU_IPV4_UDP_PAY, ICE_PTYPE_ATTR_GTP_DOWNLINK },
 522         { ICE_MAC_IPV4_GTPU_IPV4_TCP,     ICE_PTYPE_ATTR_GTP_DOWNLINK },
 523         { ICE_MAC_IPV4_GTPU_IPV4_ICMP,    ICE_PTYPE_ATTR_GTP_DOWNLINK },
 524         { ICE_MAC_IPV6_GTPU_IPV4_FRAG,    ICE_PTYPE_ATTR_GTP_DOWNLINK },
 525         { ICE_MAC_IPV6_GTPU_IPV4_PAY,     ICE_PTYPE_ATTR_GTP_DOWNLINK },
 526         { ICE_MAC_IPV6_GTPU_IPV4_UDP_PAY, ICE_PTYPE_ATTR_GTP_DOWNLINK },
 527         { ICE_MAC_IPV6_GTPU_IPV4_TCP,     ICE_PTYPE_ATTR_GTP_DOWNLINK },
 528         { ICE_MAC_IPV6_GTPU_IPV4_ICMP,    ICE_PTYPE_ATTR_GTP_DOWNLINK },
 529         { ICE_MAC_IPV4_GTPU_IPV6_FRAG,    ICE_PTYPE_ATTR_GTP_DOWNLINK },
 530         { ICE_MAC_IPV4_GTPU_IPV6_PAY,     ICE_PTYPE_ATTR_GTP_DOWNLINK },
 531         { ICE_MAC_IPV4_GTPU_IPV6_UDP_PAY, ICE_PTYPE_ATTR_GTP_DOWNLINK },
 532         { ICE_MAC_IPV4_GTPU_IPV6_TCP,     ICE_PTYPE_ATTR_GTP_DOWNLINK },
 533         { ICE_MAC_IPV4_GTPU_IPV6_ICMPV6,  ICE_PTYPE_ATTR_GTP_DOWNLINK },
 534         { ICE_MAC_IPV6_GTPU_IPV6_FRAG,    ICE_PTYPE_ATTR_GTP_DOWNLINK },
 535         { ICE_MAC_IPV6_GTPU_IPV6_PAY,     ICE_PTYPE_ATTR_GTP_DOWNLINK },
 536         { ICE_MAC_IPV6_GTPU_IPV6_UDP_PAY, ICE_PTYPE_ATTR_GTP_DOWNLINK },
 537         { ICE_MAC_IPV6_GTPU_IPV6_TCP,     ICE_PTYPE_ATTR_GTP_DOWNLINK },
 538         { ICE_MAC_IPV6_GTPU_IPV6_ICMPV6,  ICE_PTYPE_ATTR_GTP_DOWNLINK },
 539 };
 540
 541 static const struct ice_ptype_attributes ice_attr_gtpu_up[] = {
 542         { ICE_MAC_IPV4_GTPU_IPV4_FRAG,    ICE_PTYPE_ATTR_GTP_UPLINK },
 543         { ICE_MAC_IPV4_GTPU_IPV4_PAY,     ICE_PTYPE_ATTR_GTP_UPLINK },
 544         { ICE_MAC_IPV4_GTPU_IPV4_UDP_PAY, ICE_PTYPE_ATTR_GTP_UPLINK },
 545         { ICE_MAC_IPV4_GTPU_IPV4_TCP,     ICE_PTYPE_ATTR_GTP_UPLINK },
 546         { ICE_MAC_IPV4_GTPU_IPV4_ICMP,    ICE_PTYPE_ATTR_GTP_UPLINK },
 547         { ICE_MAC_IPV6_GTPU_IPV4_FRAG,    ICE_PTYPE_ATTR_GTP_UPLINK },
 548         { ICE_MAC_IPV6_GTPU_IPV4_PAY,     ICE_PTYPE_ATTR_GTP_UPLINK },
 549         { ICE_MAC_IPV6_GTPU_IPV4_UDP_PAY, ICE_PTYPE_ATTR_GTP_UPLINK },
 550         { ICE_MAC_IPV6_GTPU_IPV4_TCP,     ICE_PTYPE_ATTR_GTP_UPLINK },
 551         { ICE_MAC_IPV6_GTPU_IPV4_ICMP,    ICE_PTYPE_ATTR_GTP_UPLINK },
 552         { ICE_MAC_IPV4_GTPU_IPV6_FRAG,    ICE_PTYPE_ATTR_GTP_UPLINK },
 553         { ICE_MAC_IPV4_GTPU_IPV6_PAY,     ICE_PTYPE_ATTR_GTP_UPLINK },
 554         { ICE_MAC_IPV4_GTPU_IPV6_UDP_PAY, ICE_PTYPE_ATTR_GTP_UPLINK },
 555         { ICE_MAC_IPV4_GTPU_IPV6_TCP,     ICE_PTYPE_ATTR_GTP_UPLINK },
 556         { ICE_MAC_IPV4_GTPU_IPV6_ICMPV6,  ICE_PTYPE_ATTR_GTP_UPLINK },
 557         { ICE_MAC_IPV6_GTPU_IPV6_FRAG,    ICE_PTYPE_ATTR_GTP_UPLINK },
 558         { ICE_MAC_IPV6_GTPU_IPV6_PAY,     ICE_PTYPE_ATTR_GTP_UPLINK },
 559         { ICE_MAC_IPV6_GTPU_IPV6_UDP_PAY, ICE_PTYPE_ATTR_GTP_UPLINK },
 560         { ICE_MAC_IPV6_GTPU_IPV6_TCP,     ICE_PTYPE_ATTR_GTP_UPLINK },
 561         { ICE_MAC_IPV6_GTPU_IPV6_ICMPV6,  ICE_PTYPE_ATTR_GTP_UPLINK },
 562 };
 563
 564 static const u32 ice_ptypes_gtpu[] = {
 565         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 566         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 567         0x00000000, 0x00000000, 0x7FFFFE00, 0x00000000,
 568         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 569         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 570         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 571         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 572         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 573 };
 574
 575 /* Packet types for pppoe */
 576 static const u32 ice_ptypes_pppoe[] = {
 577         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 578         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 579         0x00000000, 0x03ffe000, 0x00000000, 0x00000000,
 580         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 581         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 582         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 583         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 584         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 585 };
 586
 587 /* Packet types for packets with PFCP NODE header */
 588 static const u32 ice_ptypes_pfcp_node[] = {
 589         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 590         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 591         0x00000000, 0x00000000, 0x80000000, 0x00000002,
 592         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 593         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 594         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 595         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 596         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 597 };
 598
 599 /* Packet types for packets with PFCP SESSION header */
 600 static const u32 ice_ptypes_pfcp_session[] = {
 601         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 602         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 603         0x00000000, 0x00000000, 0x00000000, 0x00000005,
 604         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 605         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 606         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 607         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 608         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 609 };
 610
 611 /* Packet types for l2tpv3 */
 612 static const u32 ice_ptypes_l2tpv3[] = {
 613         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 614         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 615         0x00000000, 0x00000000, 0x00000000, 0x00000300,
 616         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 617         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 618         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 619         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 620         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 621 };
 622
 623 /* Packet types for esp */
 624 static const u32 ice_ptypes_esp[] = {
 625         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 626         0x00000000, 0x00000003, 0x00000000, 0x00000000,
 627         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 628         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 629         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 630         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 631         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 632         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 633 };
 634
 635 /* Packet types for ah */
 636 static const u32 ice_ptypes_ah[] = {
 637         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 638         0x00000000, 0x0000000C, 0x00000000, 0x00000000,
 639         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 640         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 641         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 642         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 643         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 644         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 645 };
 646
 647 /* Packet types for packets with NAT_T ESP header */
 648 static const u32 ice_ptypes_nat_t_esp[] = {
 649         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 650         0x00000000, 0x00000030, 0x00000000, 0x00000000,
 651         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 652         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 653         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 654         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 655         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 656         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 657 };
 658
 659 static const u32 ice_ptypes_mac_non_ip_ofos[] = {
 660         0x00000846, 0x00000000, 0x00000000, 0x00000000,
 661         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 662         0x00400000, 0x03FFF000, 0x00000000, 0x00000000,
 663         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 664         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 665         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 666         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 667         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 668 };
 669
 670 static const u32 ice_ptypes_gtpu_no_ip[] = {
 671         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 672         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 673         0x00000000, 0x00000000, 0x00000600, 0x00000000,
 674         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 675         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 676         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 677         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 678         0x00000000, 0x00000000, 0x00000000, 0x00000000,
 679 };
 680
 681 /* Manage parameters and info. used during the creation of a flow profile */
 682 struct ice_flow_prof_params {
 683         enum ice_block blk;
 684         u16 entry_length; /* # of bytes formatted entry will require */
 685         u8 es_cnt;
 686         struct ice_flow_prof *prof;
 687
 688         /* For ACL, the es[0] will have the data of ICE_RX_MDID_PKT_FLAGS_15_0
 689          * This will give us the direction flags.
 690          */
 691         struct ice_fv_word es[ICE_MAX_FV_WORDS];
 692         /* attributes can be used to add attributes to a particular PTYPE */
 693         const struct ice_ptype_attributes *attr;
 694         u16 attr_cnt;
 695
 696         u16 mask[ICE_MAX_FV_WORDS];
 697         ice_declare_bitmap(ptypes, ICE_FLOW_PTYPE_MAX);
 698 };
 699
 700 #define ICE_FLOW_RSS_HDRS_INNER_MASK \
 701         (ICE_FLOW_SEG_HDR_PPPOE | ICE_FLOW_SEG_HDR_GTPC | \
 702         ICE_FLOW_SEG_HDR_GTPC_TEID | ICE_FLOW_SEG_HDR_GTPU | \
 703         ICE_FLOW_SEG_HDR_PFCP_SESSION | ICE_FLOW_SEG_HDR_L2TPV3 | \
 704         ICE_FLOW_SEG_HDR_ESP | ICE_FLOW_SEG_HDR_AH | \
 705         ICE_FLOW_SEG_HDR_NAT_T_ESP | ICE_FLOW_SEG_HDR_GTPU_NON_IP)
 706
 707 #define ICE_FLOW_SEG_HDRS_L2_MASK       \
 708         (ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_VLAN)
 709 #define ICE_FLOW_SEG_HDRS_L3_MASK       \
 710         (ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV6 | \
 711          ICE_FLOW_SEG_HDR_ARP)
 712 #define ICE_FLOW_SEG_HDRS_L4_MASK       \
 713         (ICE_FLOW_SEG_HDR_ICMP | ICE_FLOW_SEG_HDR_TCP | ICE_FLOW_SEG_HDR_UDP | \
 714          ICE_FLOW_SEG_HDR_SCTP)
 715 /* mask for L4 protocols that are NOT part of IPV4/6 OTHER PTYPE groups */
 716 #define ICE_FLOW_SEG_HDRS_L4_MASK_NO_OTHER      \
 717         (ICE_FLOW_SEG_HDR_TCP | ICE_FLOW_SEG_HDR_UDP | ICE_FLOW_SEG_HDR_SCTP)
 718
 719 /**
 720  * ice_flow_val_hdrs - validates packet segments for valid protocol headers
 721  * @segs: array of one or more packet segments that describe the flow
 722  * @segs_cnt: number of packet segments provided
 723  */
 724 static enum ice_status
 725 ice_flow_val_hdrs(struct ice_flow_seg_info *segs, u8 segs_cnt)
 726 {
 727         u8 i;
 728
 729         for (i = 0; i < segs_cnt; i++) {
 730                 /* Multiple L3 headers */
 731                 if (segs[i].hdrs & ICE_FLOW_SEG_HDRS_L3_MASK &&
 732                     !ice_is_pow2(segs[i].hdrs & ICE_FLOW_SEG_HDRS_L3_MASK))
 733                         return ICE_ERR_PARAM;
 734
 735                 /* Multiple L4 headers */
 736                 if (segs[i].hdrs & ICE_FLOW_SEG_HDRS_L4_MASK &&
 737                     !ice_is_pow2(segs[i].hdrs & ICE_FLOW_SEG_HDRS_L4_MASK))
 738                         return ICE_ERR_PARAM;
 739         }
 740
 741         return ICE_SUCCESS;
 742 }
 743
 744 /* Sizes of fixed known protocol headers without header options */
 745 #define ICE_FLOW_PROT_HDR_SZ_MAC        14
 746 #define ICE_FLOW_PROT_HDR_SZ_MAC_VLAN   (ICE_FLOW_PROT_HDR_SZ_MAC + 2)
 747 #define ICE_FLOW_PROT_HDR_SZ_IPV4       20
 748 #define ICE_FLOW_PROT_HDR_SZ_IPV6       40
 749 #define ICE_FLOW_PROT_HDR_SZ_ARP        28
 750 #define ICE_FLOW_PROT_HDR_SZ_ICMP       8
 751 #define ICE_FLOW_PROT_HDR_SZ_TCP        20
 752 #define ICE_FLOW_PROT_HDR_SZ_UDP        8
 753 #define ICE_FLOW_PROT_HDR_SZ_SCTP       12
 754
 755 /**
 756  * ice_flow_calc_seg_sz - calculates size of a packet segment based on headers
 757  * @params: information about the flow to be processed
 758  * @seg: index of packet segment whose header size is to be determined
 759  */
 760 static u16 ice_flow_calc_seg_sz(struct ice_flow_prof_params *params, u8 seg)
 761 {
 762         u16 sz;
 763
 764         /* L2 headers */
 765         sz = (params->prof->segs[seg].hdrs & ICE_FLOW_SEG_HDR_VLAN) ?
 766                 ICE_FLOW_PROT_HDR_SZ_MAC_VLAN : ICE_FLOW_PROT_HDR_SZ_MAC;
 767
 768         /* L3 headers */
 769         if (params->prof->segs[seg].hdrs & ICE_FLOW_SEG_HDR_IPV4)
 770                 sz += ICE_FLOW_PROT_HDR_SZ_IPV4;
 771         else if (params->prof->segs[seg].hdrs & ICE_FLOW_SEG_HDR_IPV6)
 772                 sz += ICE_FLOW_PROT_HDR_SZ_IPV6;
 773         else if (params->prof->segs[seg].hdrs & ICE_FLOW_SEG_HDR_ARP)
 774                 sz += ICE_FLOW_PROT_HDR_SZ_ARP;
 775         else if (params->prof->segs[seg].hdrs & ICE_FLOW_SEG_HDRS_L4_MASK)
 776                 /* A L3 header is required if L4 is specified */
 777                 return 0;
 778
 779         /* L4 headers */
 780         if (params->prof->segs[seg].hdrs & ICE_FLOW_SEG_HDR_ICMP)
 781                 sz += ICE_FLOW_PROT_HDR_SZ_ICMP;
 782         else if (params->prof->segs[seg].hdrs & ICE_FLOW_SEG_HDR_TCP)
 783                 sz += ICE_FLOW_PROT_HDR_SZ_TCP;
 784         else if (params->prof->segs[seg].hdrs & ICE_FLOW_SEG_HDR_UDP)
 785                 sz += ICE_FLOW_PROT_HDR_SZ_UDP;
 786         else if (params->prof->segs[seg].hdrs & ICE_FLOW_SEG_HDR_SCTP)
 787                 sz += ICE_FLOW_PROT_HDR_SZ_SCTP;
 788
 789         return sz;
 790 }
 791
 792 /**
 793  * ice_flow_proc_seg_hdrs - process protocol headers present in pkt segments
 794  * @params: information about the flow to be processed
 795  *
 796  * This function identifies the packet types associated with the protocol
 797  * headers being present in packet segments of the specified flow profile.
 798  */
 799 static enum ice_status
 800 ice_flow_proc_seg_hdrs(struct ice_flow_prof_params *params)
 801 {
 802         struct ice_flow_prof *prof;
 803         u8 i;
 804
 805         ice_memset(params->ptypes, 0xff, sizeof(params->ptypes),
 806                    ICE_NONDMA_MEM);
 807
 808         prof = params->prof;
 809
 810         for (i = 0; i < params->prof->segs_cnt; i++) {
 811                 const ice_bitmap_t *src;
 812                 u32 hdrs;
 813
 814                 hdrs = prof->segs[i].hdrs;
 815
 816                 if (hdrs & ICE_FLOW_SEG_HDR_ETH) {
 817                         src = !i ? (const ice_bitmap_t *)ice_ptypes_mac_ofos :
 818                                 (const ice_bitmap_t *)ice_ptypes_mac_il;
 819                         ice_and_bitmap(params->ptypes, params->ptypes, src,
 820                                        ICE_FLOW_PTYPE_MAX);
 821                 }
 822
 823                 if (i && hdrs & ICE_FLOW_SEG_HDR_VLAN) {
 824                         src = (const ice_bitmap_t *)ice_ptypes_macvlan_il;
 825                         ice_and_bitmap(params->ptypes, params->ptypes, src,
 826                                        ICE_FLOW_PTYPE_MAX);
 827                 }
 828
 829                 if (!i && hdrs & ICE_FLOW_SEG_HDR_ARP) {
 830                         ice_and_bitmap(params->ptypes, params->ptypes,
 831                                        (const ice_bitmap_t *)ice_ptypes_arp_of,
 832                                        ICE_FLOW_PTYPE_MAX);
 833                 }
 834
 835                 if (hdrs & ICE_FLOW_SEG_HDR_PPPOE) {
 836                         src = (const ice_bitmap_t *)ice_ptypes_pppoe;
 837                         ice_and_bitmap(params->ptypes, params->ptypes, src,
 838                                        ICE_FLOW_PTYPE_MAX);
 839                 }
 840                 if ((hdrs & ICE_FLOW_SEG_HDR_IPV4) &&
 841                     (hdrs & ICE_FLOW_SEG_HDR_IPV_OTHER)) {
 842                         src = i ?
 843                                 (const ice_bitmap_t *)ice_ptypes_ipv4_il :
 844                                 (const ice_bitmap_t *)ice_ptypes_ipv4_ofos_all;
 845                         ice_and_bitmap(params->ptypes, params->ptypes, src,
 846                                        ICE_FLOW_PTYPE_MAX);
 847                 } else if ((hdrs & ICE_FLOW_SEG_HDR_IPV6) &&
 848                            (hdrs & ICE_FLOW_SEG_HDR_IPV_OTHER)) {
 849                         src = i ?
 850                                 (const ice_bitmap_t *)ice_ptypes_ipv6_il :
 851                                 (const ice_bitmap_t *)ice_ptypes_ipv6_ofos_all;
 852                         ice_and_bitmap(params->ptypes, params->ptypes, src,
 853                                        ICE_FLOW_PTYPE_MAX);
 854                 } else if ((hdrs & ICE_FLOW_SEG_HDR_IPV4) &&
 855                            !(hdrs & ICE_FLOW_SEG_HDRS_L4_MASK_NO_OTHER)) {
 856                         src = !i ? (const ice_bitmap_t *)ice_ipv4_ofos_no_l4 :
 857                                 (const ice_bitmap_t *)ice_ipv4_il_no_l4;
 858                         ice_and_bitmap(params->ptypes, params->ptypes, src,
 859                                        ICE_FLOW_PTYPE_MAX);
 860                 } else if (hdrs & ICE_FLOW_SEG_HDR_IPV4) {
 861                         src = !i ? (const ice_bitmap_t *)ice_ptypes_ipv4_ofos :
 862                                 (const ice_bitmap_t *)ice_ptypes_ipv4_il;
 863                         ice_and_bitmap(params->ptypes, params->ptypes, src,
 864                                        ICE_FLOW_PTYPE_MAX);
 865                 } else if ((hdrs & ICE_FLOW_SEG_HDR_IPV6) &&
 866                            !(hdrs & ICE_FLOW_SEG_HDRS_L4_MASK_NO_OTHER)) {
 867                         src = !i ? (const ice_bitmap_t *)ice_ipv6_ofos_no_l4 :
 868                                 (const ice_bitmap_t *)ice_ipv6_il_no_l4;
 869                         ice_and_bitmap(params->ptypes, params->ptypes, src,
 870                                        ICE_FLOW_PTYPE_MAX);
 871                 } else if (hdrs & ICE_FLOW_SEG_HDR_IPV6) {
 872                         src = !i ? (const ice_bitmap_t *)ice_ptypes_ipv6_ofos :
 873                                 (const ice_bitmap_t *)ice_ptypes_ipv6_il;
 874                         ice_and_bitmap(params->ptypes, params->ptypes, src,
 875                                        ICE_FLOW_PTYPE_MAX);
 876                 }
 877
 878                 if (hdrs & ICE_FLOW_SEG_HDR_ETH_NON_IP) {
 879                         src = (const ice_bitmap_t *)ice_ptypes_mac_non_ip_ofos;
 880                         ice_and_bitmap(params->ptypes, params->ptypes,
 881                                        src, ICE_FLOW_PTYPE_MAX);
 882                 } else if (hdrs & ICE_FLOW_SEG_HDR_PPPOE) {
 883                         src = (const ice_bitmap_t *)ice_ptypes_pppoe;
 884                         ice_and_bitmap(params->ptypes, params->ptypes, src,
 885                                        ICE_FLOW_PTYPE_MAX);
 886                 } else {
 887                         src = (const ice_bitmap_t *)ice_ptypes_pppoe;
 888                         ice_andnot_bitmap(params->ptypes, params->ptypes, src,
 889                                           ICE_FLOW_PTYPE_MAX);
 890                 }
 891
 892                 if (hdrs & ICE_FLOW_SEG_HDR_UDP) {
 893                         src = (const ice_bitmap_t *)ice_ptypes_udp_il;
 894                         ice_and_bitmap(params->ptypes, params->ptypes, src,
 895                                        ICE_FLOW_PTYPE_MAX);
 896                 } else if (hdrs & ICE_FLOW_SEG_HDR_TCP) {
 897                         ice_and_bitmap(params->ptypes, params->ptypes,
 898                                        (const ice_bitmap_t *)ice_ptypes_tcp_il,
 899                                        ICE_FLOW_PTYPE_MAX);
 900                 } else if (hdrs & ICE_FLOW_SEG_HDR_SCTP) {
 901                         src = (const ice_bitmap_t *)ice_ptypes_sctp_il;
 902                         ice_and_bitmap(params->ptypes, params->ptypes, src,
 903                                        ICE_FLOW_PTYPE_MAX);
 904                 }
 905
 906                 if (hdrs & ICE_FLOW_SEG_HDR_ICMP) {
 907                         src = !i ? (const ice_bitmap_t *)ice_ptypes_icmp_of :
 908                                 (const ice_bitmap_t *)ice_ptypes_icmp_il;
 909                         ice_and_bitmap(params->ptypes, params->ptypes, src,
 910                                        ICE_FLOW_PTYPE_MAX);
 911                 } else if (hdrs & ICE_FLOW_SEG_HDR_GRE) {
 912                         if (!i) {
 913                                 src = (const ice_bitmap_t *)ice_ptypes_gre_of;
 914                                 ice_and_bitmap(params->ptypes, params->ptypes,
 915                                                src, ICE_FLOW_PTYPE_MAX);
 916                         }
 917                 } else if (hdrs & ICE_FLOW_SEG_HDR_GTPC) {
 918                         src = (const ice_bitmap_t *)ice_ptypes_gtpc;
 919                         ice_and_bitmap(params->ptypes, params->ptypes,
 920                                        src, ICE_FLOW_PTYPE_MAX);
 921                 } else if (hdrs & ICE_FLOW_SEG_HDR_GTPC_TEID) {
 922                         src = (const ice_bitmap_t *)ice_ptypes_gtpc_tid;
 923                         ice_and_bitmap(params->ptypes, params->ptypes,
 924                                        src, ICE_FLOW_PTYPE_MAX);
 925                 } else if (hdrs & ICE_FLOW_SEG_HDR_GTPU_NON_IP) {
 926                         src = (const ice_bitmap_t *)ice_ptypes_gtpu_no_ip;
 927                         ice_and_bitmap(params->ptypes, params->ptypes,
 928                                        src, ICE_FLOW_PTYPE_MAX);
 929                 } else if (hdrs & ICE_FLOW_SEG_HDR_GTPU_DWN) {
 930                         src = (const ice_bitmap_t *)ice_ptypes_gtpu;
 931                         ice_and_bitmap(params->ptypes, params->ptypes,
 932                                        src, ICE_FLOW_PTYPE_MAX);
 933
 934                         /* Attributes for GTP packet with downlink */
 935                         params->attr = ice_attr_gtpu_down;
 936                         params->attr_cnt = ARRAY_SIZE(ice_attr_gtpu_down);
 937                 } else if (hdrs & ICE_FLOW_SEG_HDR_GTPU_UP) {
 938                         src = (const ice_bitmap_t *)ice_ptypes_gtpu;
 939                         ice_and_bitmap(params->ptypes, params->ptypes,
 940                                        src, ICE_FLOW_PTYPE_MAX);
 941
 942                         /* Attributes for GTP packet with uplink */
 943                         params->attr = ice_attr_gtpu_up;
 944                         params->attr_cnt = ARRAY_SIZE(ice_attr_gtpu_up);
 945                 } else if (hdrs & ICE_FLOW_SEG_HDR_GTPU_EH) {
 946                         src = (const ice_bitmap_t *)ice_ptypes_gtpu;
 947                         ice_and_bitmap(params->ptypes, params->ptypes,
 948                                        src, ICE_FLOW_PTYPE_MAX);
 949
 950                         /* Attributes for GTP packet with Extension Header */
 951                         params->attr = ice_attr_gtpu_eh;
 952                         params->attr_cnt = ARRAY_SIZE(ice_attr_gtpu_eh);
 953                 } else if (hdrs & ICE_FLOW_SEG_HDR_GTPU_IP) {
 954                         src = (const ice_bitmap_t *)ice_ptypes_gtpu;
 955                         ice_and_bitmap(params->ptypes, params->ptypes,
 956                                        src, ICE_FLOW_PTYPE_MAX);
 957
 958                         /* Attributes for GTP packet without Extension Header */
 959                         params->attr = ice_attr_gtpu_session;
 960                         params->attr_cnt = ARRAY_SIZE(ice_attr_gtpu_session);
 961                 } else if (hdrs & ICE_FLOW_SEG_HDR_L2TPV3) {
 962                         src = (const ice_bitmap_t *)ice_ptypes_l2tpv3;
 963                         ice_and_bitmap(params->ptypes, params->ptypes,
 964                                        src, ICE_FLOW_PTYPE_MAX);
 965                 } else if (hdrs & ICE_FLOW_SEG_HDR_ESP) {
 966                         src = (const ice_bitmap_t *)ice_ptypes_esp;
 967                         ice_and_bitmap(params->ptypes, params->ptypes,
 968                                        src, ICE_FLOW_PTYPE_MAX);
 969                 } else if (hdrs & ICE_FLOW_SEG_HDR_AH) {
 970                         src = (const ice_bitmap_t *)ice_ptypes_ah;
 971                         ice_and_bitmap(params->ptypes, params->ptypes,
 972                                        src, ICE_FLOW_PTYPE_MAX);
 973                 } else if (hdrs & ICE_FLOW_SEG_HDR_NAT_T_ESP) {
 974                         src = (const ice_bitmap_t *)ice_ptypes_nat_t_esp;
 975                         ice_and_bitmap(params->ptypes, params->ptypes,
 976                                        src, ICE_FLOW_PTYPE_MAX);
 977                 }
 978
 979                 if (hdrs & ICE_FLOW_SEG_HDR_PFCP) {
 980                         if (hdrs & ICE_FLOW_SEG_HDR_PFCP_NODE)
 981                                 src =
 982                                 (const ice_bitmap_t *)ice_ptypes_pfcp_node;
 983                         else
 984                                 src =
 985                                 (const ice_bitmap_t *)ice_ptypes_pfcp_session;
 986
 987                         ice_and_bitmap(params->ptypes, params->ptypes,
 988                                        src, ICE_FLOW_PTYPE_MAX);
 989                 } else {
 990                         src = (const ice_bitmap_t *)ice_ptypes_pfcp_node;
 991                         ice_andnot_bitmap(params->ptypes, params->ptypes,
 992                                           src, ICE_FLOW_PTYPE_MAX);
 993
 994                         src = (const ice_bitmap_t *)ice_ptypes_pfcp_session;
 995                         ice_andnot_bitmap(params->ptypes, params->ptypes,
 996                                           src, ICE_FLOW_PTYPE_MAX);
 997                 }
 998         }
 999
1000         return ICE_SUCCESS;
1001 }
1002
1003 /**
1004  * ice_flow_xtract_pkt_flags - Create an extr sequence entry for packet flags
1005  * @hw: pointer to the HW struct
1006  * @params: information about the flow to be processed
1007  * @flags: The value of pkt_flags[x:x] in Rx/Tx MDID metadata.
1008  *
1009  * This function will allocate an extraction sequence entries for a DWORD size
1010  * chunk of the packet flags.
1011  */
1012 static enum ice_status
1013 ice_flow_xtract_pkt_flags(struct ice_hw *hw,
1014                           struct ice_flow_prof_params *params,
1015                           enum ice_flex_mdid_pkt_flags flags)
1016 {
1017         u8 fv_words = hw->blk[params->blk].es.fvw;
1018         u8 idx;
1019
1020         /* Make sure the number of extraction sequence entries required does not
1021          * exceed the block's capacity.
1022          */
1023         if (params->es_cnt >= fv_words)
1024                 return ICE_ERR_MAX_LIMIT;
1025
1026         /* some blocks require a reversed field vector layout */
1027         if (hw->blk[params->blk].es.reverse)
1028                 idx = fv_words - params->es_cnt - 1;
1029         else
1030                 idx = params->es_cnt;
1031
1032         params->es[idx].prot_id = ICE_PROT_META_ID;
1033         params->es[idx].off = flags;
1034         params->es_cnt++;
1035
1036         return ICE_SUCCESS;
1037 }
1038
1039 /**
1040  * ice_flow_xtract_fld - Create an extraction sequence entry for the given field
1041  * @hw: pointer to the HW struct
1042  * @params: information about the flow to be processed
1043  * @seg: packet segment index of the field to be extracted
1044  * @fld: ID of field to be extracted
1045  * @match: bitfield of all fields
1046  *
1047  * This function determines the protocol ID, offset, and size of the given
1048  * field. It then allocates one or more extraction sequence entries for the
1049  * given field, and fill the entries with protocol ID and offset information.
1050  */
1051 static enum ice_status
1052 ice_flow_xtract_fld(struct ice_hw *hw, struct ice_flow_prof_params *params,
1053                     u8 seg, enum ice_flow_field fld, u64 match)
1054 {
1055         enum ice_flow_field sib = ICE_FLOW_FIELD_IDX_MAX;
1056         enum ice_prot_id prot_id = ICE_PROT_ID_INVAL;
1057         u8 fv_words = hw->blk[params->blk].es.fvw;
1058         struct ice_flow_fld_info *flds;
1059         u16 cnt, ese_bits, i;
1060         u16 sib_mask = 0;
1061         u16 mask;
1062         u16 off;
1063
1064         flds = params->prof->segs[seg].fields;
1065
1066         switch (fld) {
1067         case ICE_FLOW_FIELD_IDX_ETH_DA:
1068         case ICE_FLOW_FIELD_IDX_ETH_SA:
1069         case ICE_FLOW_FIELD_IDX_S_VLAN:
1070         case ICE_FLOW_FIELD_IDX_C_VLAN:
1071                 prot_id = seg == 0 ? ICE_PROT_MAC_OF_OR_S : ICE_PROT_MAC_IL;
1072                 break;
1073         case ICE_FLOW_FIELD_IDX_ETH_TYPE:
1074                 prot_id = seg == 0 ? ICE_PROT_ETYPE_OL : ICE_PROT_ETYPE_IL;
1075                 break;
1076         case ICE_FLOW_FIELD_IDX_IPV4_DSCP:
1077                 prot_id = seg == 0 ? ICE_PROT_IPV4_OF_OR_S : ICE_PROT_IPV4_IL;
1078                 break;
1079         case ICE_FLOW_FIELD_IDX_IPV6_DSCP:
1080                 prot_id = seg == 0 ? ICE_PROT_IPV6_OF_OR_S : ICE_PROT_IPV6_IL;
1081                 break;
1082         case ICE_FLOW_FIELD_IDX_IPV4_TTL:
1083         case ICE_FLOW_FIELD_IDX_IPV4_PROT:
1084                 prot_id = seg == 0 ? ICE_PROT_IPV4_OF_OR_S : ICE_PROT_IPV4_IL;
1085
1086                 /* TTL and PROT share the same extraction seq. entry.
1087                  * Each is considered a sibling to the other in terms of sharing
1088                  * the same extraction sequence entry.
1089                  */
1090                 if (fld == ICE_FLOW_FIELD_IDX_IPV4_TTL)
1091                         sib = ICE_FLOW_FIELD_IDX_IPV4_PROT;
1092                 else if (fld == ICE_FLOW_FIELD_IDX_IPV4_PROT)
1093                         sib = ICE_FLOW_FIELD_IDX_IPV4_TTL;
1094
1095                 /* If the sibling field is also included, that field's
1096                  * mask needs to be included.
1097                  */
1098                 if (match & BIT(sib))
1099                         sib_mask = ice_flds_info[sib].mask;
1100                 break;
1101         case ICE_FLOW_FIELD_IDX_IPV6_TTL:
1102         case ICE_FLOW_FIELD_IDX_IPV6_PROT:
1103                 prot_id = seg == 0 ? ICE_PROT_IPV6_OF_OR_S : ICE_PROT_IPV6_IL;
1104
1105                 /* TTL and PROT share the same extraction seq. entry.
1106                  * Each is considered a sibling to the other in terms of sharing
1107                  * the same extraction sequence entry.
1108                  */
1109                 if (fld == ICE_FLOW_FIELD_IDX_IPV6_TTL)
1110                         sib = ICE_FLOW_FIELD_IDX_IPV6_PROT;
1111                 else if (fld == ICE_FLOW_FIELD_IDX_IPV6_PROT)
1112                         sib = ICE_FLOW_FIELD_IDX_IPV6_TTL;
1113
1114                 /* If the sibling field is also included, that field's
1115                  * mask needs to be included.
1116                  */
1117                 if (match & BIT(sib))
1118                         sib_mask = ice_flds_info[sib].mask;
1119                 break;
1120         case ICE_FLOW_FIELD_IDX_IPV4_SA:
1121         case ICE_FLOW_FIELD_IDX_IPV4_DA:
1122                 prot_id = seg == 0 ? ICE_PROT_IPV4_OF_OR_S : ICE_PROT_IPV4_IL;
1123                 break;
1124         case ICE_FLOW_FIELD_IDX_IPV6_SA:
1125         case ICE_FLOW_FIELD_IDX_IPV6_DA:
1126         case ICE_FLOW_FIELD_IDX_IPV6_PRE32_SA:
1127         case ICE_FLOW_FIELD_IDX_IPV6_PRE32_DA:
1128         case ICE_FLOW_FIELD_IDX_IPV6_PRE48_SA:
1129         case ICE_FLOW_FIELD_IDX_IPV6_PRE48_DA:
1130         case ICE_FLOW_FIELD_IDX_IPV6_PRE64_SA:
1131         case ICE_FLOW_FIELD_IDX_IPV6_PRE64_DA:
1132                 prot_id = seg == 0 ? ICE_PROT_IPV6_OF_OR_S : ICE_PROT_IPV6_IL;
1133                 break;
1134         case ICE_FLOW_FIELD_IDX_TCP_SRC_PORT:
1135         case ICE_FLOW_FIELD_IDX_TCP_DST_PORT:
1136         case ICE_FLOW_FIELD_IDX_TCP_FLAGS:
1137                 prot_id = ICE_PROT_TCP_IL;
1138                 break;
1139         case ICE_FLOW_FIELD_IDX_UDP_SRC_PORT:
1140         case ICE_FLOW_FIELD_IDX_UDP_DST_PORT:
1141                 prot_id = ICE_PROT_UDP_IL_OR_S;
1142                 break;
1143         case ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT:
1144         case ICE_FLOW_FIELD_IDX_SCTP_DST_PORT:
1145                 prot_id = ICE_PROT_SCTP_IL;
1146                 break;
1147         case ICE_FLOW_FIELD_IDX_GTPC_TEID:
1148         case ICE_FLOW_FIELD_IDX_GTPU_IP_TEID:
1149         case ICE_FLOW_FIELD_IDX_GTPU_UP_TEID:
1150         case ICE_FLOW_FIELD_IDX_GTPU_DWN_TEID:
1151         case ICE_FLOW_FIELD_IDX_GTPU_EH_TEID:
1152         case ICE_FLOW_FIELD_IDX_GTPU_EH_QFI:
1153                 /* GTP is accessed through UDP OF protocol */
1154                 prot_id = ICE_PROT_UDP_OF;
1155                 break;
1156         case ICE_FLOW_FIELD_IDX_PPPOE_SESS_ID:
1157                 prot_id = ICE_PROT_PPPOE;
1158                 break;
1159         case ICE_FLOW_FIELD_IDX_PFCP_SEID:
1160                 prot_id = ICE_PROT_UDP_IL_OR_S;
1161                 break;
1162         case ICE_FLOW_FIELD_IDX_L2TPV3_SESS_ID:
1163                 prot_id = ICE_PROT_L2TPV3;
1164                 break;
1165         case ICE_FLOW_FIELD_IDX_ESP_SPI:
1166                 prot_id = ICE_PROT_ESP_F;
1167                 break;
1168         case ICE_FLOW_FIELD_IDX_AH_SPI:
1169                 prot_id = ICE_PROT_ESP_2;
1170                 break;
1171         case ICE_FLOW_FIELD_IDX_NAT_T_ESP_SPI:
1172                 prot_id = ICE_PROT_UDP_IL_OR_S;
1173                 break;
1174         case ICE_FLOW_FIELD_IDX_ARP_SIP:
1175         case ICE_FLOW_FIELD_IDX_ARP_DIP:
1176         case ICE_FLOW_FIELD_IDX_ARP_SHA:
1177         case ICE_FLOW_FIELD_IDX_ARP_DHA:
1178         case ICE_FLOW_FIELD_IDX_ARP_OP:
1179                 prot_id = ICE_PROT_ARP_OF;
1180                 break;
1181         case ICE_FLOW_FIELD_IDX_ICMP_TYPE:
1182         case ICE_FLOW_FIELD_IDX_ICMP_CODE:
1183                 /* ICMP type and code share the same extraction seq. entry */
1184                 prot_id = (params->prof->segs[seg].hdrs &
1185                            ICE_FLOW_SEG_HDR_IPV4) ?
1186                         ICE_PROT_ICMP_IL : ICE_PROT_ICMPV6_IL;
1187                 sib = fld == ICE_FLOW_FIELD_IDX_ICMP_TYPE ?
1188                         ICE_FLOW_FIELD_IDX_ICMP_CODE :
1189                         ICE_FLOW_FIELD_IDX_ICMP_TYPE;
1190                 break;
1191         case ICE_FLOW_FIELD_IDX_GRE_KEYID:
1192                 prot_id = ICE_PROT_GRE_OF;
1193                 break;
1194         default:
1195                 return ICE_ERR_NOT_IMPL;
1196         }
1197
1198         /* Each extraction sequence entry is a word in size, and extracts a
1199          * word-aligned offset from a protocol header.
1200          */
1201         ese_bits = ICE_FLOW_FV_EXTRACT_SZ * BITS_PER_BYTE;
1202
1203         flds[fld].xtrct.prot_id = prot_id;
1204         flds[fld].xtrct.off = (ice_flds_info[fld].off / ese_bits) *
1205                 ICE_FLOW_FV_EXTRACT_SZ;
1206         flds[fld].xtrct.disp = (u8)(ice_flds_info[fld].off % ese_bits);
1207         flds[fld].xtrct.idx = params->es_cnt;
1208         flds[fld].xtrct.mask = ice_flds_info[fld].mask;
1209
1210         /* Adjust the next field-entry index after accommodating the number of
1211          * entries this field consumes
1212          */
1213         cnt = DIVIDE_AND_ROUND_UP(flds[fld].xtrct.disp +
1214                                   ice_flds_info[fld].size, ese_bits);
1215
1216         /* Fill in the extraction sequence entries needed for this field */
1217         off = flds[fld].xtrct.off;
1218         mask = flds[fld].xtrct.mask;
1219         for (i = 0; i < cnt; i++) {
1220                 /* Only consume an extraction sequence entry if there is no
1221                  * sibling field associated with this field or the sibling entry
1222                  * already extracts the word shared with this field.
1223                  */
1224                 if (sib == ICE_FLOW_FIELD_IDX_MAX ||
1225                     flds[sib].xtrct.prot_id == ICE_PROT_ID_INVAL ||
1226                     flds[sib].xtrct.off != off) {
1227                         u8 idx;
1228
1229                         /* Make sure the number of extraction sequence required
1230                          * does not exceed the block's capability
1231                          */
1232                         if (params->es_cnt >= fv_words)
1233                                 return ICE_ERR_MAX_LIMIT;
1234
1235                         /* some blocks require a reversed field vector layout */
1236                         if (hw->blk[params->blk].es.reverse)
1237                                 idx = fv_words - params->es_cnt - 1;
1238                         else
1239                                 idx = params->es_cnt;
1240
1241                         params->es[idx].prot_id = prot_id;
1242                         params->es[idx].off = off;
1243                         params->mask[idx] = mask | sib_mask;
1244                         params->es_cnt++;
1245                 }
1246
1247                 off += ICE_FLOW_FV_EXTRACT_SZ;
1248         }
1249
1250         return ICE_SUCCESS;
1251 }
1252
1253 /**
1254  * ice_flow_xtract_raws - Create extract sequence entries for raw bytes
1255  * @hw: pointer to the HW struct
1256  * @params: information about the flow to be processed
1257  * @seg: index of packet segment whose raw fields are to be be extracted
1258  */
1259 static enum ice_status
1260 ice_flow_xtract_raws(struct ice_hw *hw, struct ice_flow_prof_params *params,
1261                      u8 seg)
1262 {
1263         u16 fv_words;
1264         u16 hdrs_sz;
1265         u8 i;
1266
1267         if (!params->prof->segs[seg].raws_cnt)
1268                 return ICE_SUCCESS;
1269
1270         if (params->prof->segs[seg].raws_cnt >
1271             ARRAY_SIZE(params->prof->segs[seg].raws))
1272                 return ICE_ERR_MAX_LIMIT;
1273
1274         /* Offsets within the segment headers are not supported */
1275         hdrs_sz = ice_flow_calc_seg_sz(params, seg);
1276         if (!hdrs_sz)
1277                 return ICE_ERR_PARAM;
1278
1279         fv_words = hw->blk[params->blk].es.fvw;
1280
1281         for (i = 0; i < params->prof->segs[seg].raws_cnt; i++) {
1282                 struct ice_flow_seg_fld_raw *raw;
1283                 u16 off, cnt, j;
1284
1285                 raw = &params->prof->segs[seg].raws[i];
1286
1287                 /* Storing extraction information */
1288                 raw->info.xtrct.prot_id = ICE_PROT_MAC_OF_OR_S;
1289                 raw->info.xtrct.off = (raw->off / ICE_FLOW_FV_EXTRACT_SZ) *
1290                         ICE_FLOW_FV_EXTRACT_SZ;
1291                 raw->info.xtrct.disp = (raw->off % ICE_FLOW_FV_EXTRACT_SZ) *
1292                         BITS_PER_BYTE;
1293                 raw->info.xtrct.idx = params->es_cnt;
1294
1295                 /* Determine the number of field vector entries this raw field
1296                  * consumes.
1297                  */
1298                 cnt = DIVIDE_AND_ROUND_UP(raw->info.xtrct.disp +
1299                                           (raw->info.src.last * BITS_PER_BYTE),
1300                                           (ICE_FLOW_FV_EXTRACT_SZ *
1301                                            BITS_PER_BYTE));
1302                 off = raw->info.xtrct.off;
1303                 for (j = 0; j < cnt; j++) {
1304                         u16 idx;
1305
1306                         /* Make sure the number of extraction sequence required
1307                          * does not exceed the block's capability
1308                          */
1309                         if (params->es_cnt >= hw->blk[params->blk].es.count ||
1310                             params->es_cnt >= ICE_MAX_FV_WORDS)
1311                                 return ICE_ERR_MAX_LIMIT;
1312
1313                         /* some blocks require a reversed field vector layout */
1314                         if (hw->blk[params->blk].es.reverse)
1315                                 idx = fv_words - params->es_cnt - 1;
1316                         else
1317                                 idx = params->es_cnt;
1318
1319                         params->es[idx].prot_id = raw->info.xtrct.prot_id;
1320                         params->es[idx].off = off;
1321                         params->es_cnt++;
1322                         off += ICE_FLOW_FV_EXTRACT_SZ;
1323                 }
1324         }
1325
1326         return ICE_SUCCESS;
1327 }
1328
1329 /**
1330  * ice_flow_create_xtrct_seq - Create an extraction sequence for given segments
1331  * @hw: pointer to the HW struct
1332  * @params: information about the flow to be processed
1333  *
1334  * This function iterates through all matched fields in the given segments, and
1335  * creates an extraction sequence for the fields.
1336  */
1337 static enum ice_status
1338 ice_flow_create_xtrct_seq(struct ice_hw *hw,
1339                           struct ice_flow_prof_params *params)
1340 {
1341         enum ice_status status = ICE_SUCCESS;
1342         u8 i;
1343
1344         /* For ACL, we also need to extract the direction bit (Rx,Tx) data from
1345          * packet flags
1346          */
1347         if (params->blk == ICE_BLK_ACL) {
1348                 status = ice_flow_xtract_pkt_flags(hw, params,
1349                                                    ICE_RX_MDID_PKT_FLAGS_15_0);
1350                 if (status)
1351                         return status;
1352         }
1353
1354         for (i = 0; i < params->prof->segs_cnt; i++) {
1355                 u64 match = params->prof->segs[i].match;
1356                 enum ice_flow_field j;
1357
1358                 ice_for_each_set_bit(j, (ice_bitmap_t *)&match,
1359                                      ICE_FLOW_FIELD_IDX_MAX) {
1360                         status = ice_flow_xtract_fld(hw, params, i, j, match);
1361                         if (status)
1362                                 return status;
1363                         ice_clear_bit(j, (ice_bitmap_t *)&match);
1364                 }
1365
1366                 /* Process raw matching bytes */
1367                 status = ice_flow_xtract_raws(hw, params, i);
1368                 if (status)
1369                         return status;
1370         }
1371
1372         return status;
1373 }
1374
1375 /**
1376  * ice_flow_sel_acl_scen - returns the specific scenario
1377  * @hw: pointer to the hardware structure
1378  * @params: information about the flow to be processed
1379  *
1380  * This function will return the specific scenario based on the
1381  * params passed to it
1382  */
1383 static enum ice_status
1384 ice_flow_sel_acl_scen(struct ice_hw *hw, struct ice_flow_prof_params *params)
1385 {
1386         /* Find the best-fit scenario for the provided match width */
1387         struct ice_acl_scen *cand_scen = NULL, *scen;
1388
1389         if (!hw->acl_tbl)
1390                 return ICE_ERR_DOES_NOT_EXIST;
1391
1392         /* Loop through each scenario and match against the scenario width
1393          * to select the specific scenario
1394          */
1395         LIST_FOR_EACH_ENTRY(scen, &hw->acl_tbl->scens, ice_acl_scen, list_entry)
1396                 if (scen->eff_width >= params->entry_length &&
1397                     (!cand_scen || cand_scen->eff_width > scen->eff_width))
1398                         cand_scen = scen;
1399         if (!cand_scen)
1400                 return ICE_ERR_DOES_NOT_EXIST;
1401
1402         params->prof->cfg.scen = cand_scen;
1403
1404         return ICE_SUCCESS;
1405 }
1406
1407 /**
1408  * ice_flow_acl_def_entry_frmt - Determine the layout of flow entries
1409  * @params: information about the flow to be processed
1410  */
1411 static enum ice_status
1412 ice_flow_acl_def_entry_frmt(struct ice_flow_prof_params *params)
1413 {
1414         u16 index, i, range_idx = 0;
1415
1416         index = ICE_AQC_ACL_PROF_BYTE_SEL_START_IDX;
1417
1418         for (i = 0; i < params->prof->segs_cnt; i++) {
1419                 struct ice_flow_seg_info *seg = &params->prof->segs[i];
1420                 u8 j;
1421
1422                 ice_for_each_set_bit(j, (ice_bitmap_t *)&seg->match,
1423                                      ICE_FLOW_FIELD_IDX_MAX) {
1424                         struct ice_flow_fld_info *fld = &seg->fields[j];
1425
1426                         fld->entry.mask = ICE_FLOW_FLD_OFF_INVAL;
1427
1428                         if (fld->type == ICE_FLOW_FLD_TYPE_RANGE) {
1429                                 fld->entry.last = ICE_FLOW_FLD_OFF_INVAL;
1430
1431                                 /* Range checking only supported for single
1432                                  * words
1433                                  */
1434                                 if (DIVIDE_AND_ROUND_UP(ice_flds_info[j].size +
1435                                                         fld->xtrct.disp,
1436                                                         BITS_PER_BYTE * 2) > 1)
1437                                         return ICE_ERR_PARAM;
1438
1439                                 /* Ranges must define low and high values */
1440                                 if (fld->src.val == ICE_FLOW_FLD_OFF_INVAL ||
1441                                     fld->src.last == ICE_FLOW_FLD_OFF_INVAL)
1442                                         return ICE_ERR_PARAM;
1443
1444                                 fld->entry.val = range_idx++;
1445                         } else {
1446                                 /* Store adjusted byte-length of field for later
1447                                  * use, taking into account potential
1448                                  * non-byte-aligned displacement
1449                                  */
1450                                 fld->entry.last = DIVIDE_AND_ROUND_UP
1451                                         (ice_flds_info[j].size +
1452                                          (fld->xtrct.disp % BITS_PER_BYTE),
1453                                          BITS_PER_BYTE);
1454                                 fld->entry.val = index;
1455                                 index += fld->entry.last;
1456                         }
1457                 }
1458
1459                 for (j = 0; j < seg->raws_cnt; j++) {
1460                         struct ice_flow_seg_fld_raw *raw = &seg->raws[j];
1461
1462                         raw->info.entry.mask = ICE_FLOW_FLD_OFF_INVAL;
1463                         raw->info.entry.val = index;
1464                         raw->info.entry.last = raw->info.src.last;
1465                         index += raw->info.entry.last;
1466                 }
1467         }
1468
1469         /* Currently only support using the byte selection base, which only
1470          * allows for an effective entry size of 30 bytes. Reject anything
1471          * larger.
1472          */
1473         if (index > ICE_AQC_ACL_PROF_BYTE_SEL_ELEMS)
1474                 return ICE_ERR_PARAM;
1475
1476         /* Only 8 range checkers per profile, reject anything trying to use
1477          * more
1478          */
1479         if (range_idx > ICE_AQC_ACL_PROF_RANGES_NUM_CFG)
1480                 return ICE_ERR_PARAM;
1481
1482         /* Store # bytes required for entry for later use */
1483         params->entry_length = index - ICE_AQC_ACL_PROF_BYTE_SEL_START_IDX;
1484
1485         return ICE_SUCCESS;
1486 }
1487
1488 /**
1489  * ice_flow_proc_segs - process all packet segments associated with a profile
1490  * @hw: pointer to the HW struct
1491  * @params: information about the flow to be processed
1492  */
1493 static enum ice_status
1494 ice_flow_proc_segs(struct ice_hw *hw, struct ice_flow_prof_params *params)
1495 {
1496         enum ice_status status;
1497
1498         status = ice_flow_proc_seg_hdrs(params);
1499         if (status)
1500                 return status;
1501
1502         status = ice_flow_create_xtrct_seq(hw, params);
1503         if (status)
1504                 return status;
1505
1506         switch (params->blk) {
1507         case ICE_BLK_FD:
1508         case ICE_BLK_RSS:
1509                 status = ICE_SUCCESS;
1510                 break;
1511         case ICE_BLK_ACL:
1512                 status = ice_flow_acl_def_entry_frmt(params);
1513                 if (status)
1514                         return status;
1515                 status = ice_flow_sel_acl_scen(hw, params);
1516                 if (status)
1517                         return status;
1518                 break;
1519         default:
1520                 return ICE_ERR_NOT_IMPL;
1521         }
1522
1523         return status;
1524 }
1525
1526 #define ICE_FLOW_FIND_PROF_CHK_FLDS     0x00000001
1527 #define ICE_FLOW_FIND_PROF_CHK_VSI      0x00000002
1528 #define ICE_FLOW_FIND_PROF_NOT_CHK_DIR  0x00000004
1529
1530 /**
1531  * ice_flow_find_prof_conds - Find a profile matching headers and conditions
1532  * @hw: pointer to the HW struct
1533  * @blk: classification stage
1534  * @dir: flow direction
1535  * @segs: array of one or more packet segments that describe the flow
1536  * @segs_cnt: number of packet segments provided
1537  * @vsi_handle: software VSI handle to check VSI (ICE_FLOW_FIND_PROF_CHK_VSI)
1538  * @conds: additional conditions to be checked (ICE_FLOW_FIND_PROF_CHK_*)
1539  */
1540 static struct ice_flow_prof *
1541 ice_flow_find_prof_conds(struct ice_hw *hw, enum ice_block blk,
1542                          enum ice_flow_dir dir, struct ice_flow_seg_info *segs,
1543                          u8 segs_cnt, u16 vsi_handle, u32 conds)
1544 {
1545         struct ice_flow_prof *p, *prof = NULL;
1546
1547         ice_acquire_lock(&hw->fl_profs_locks[blk]);
1548         LIST_FOR_EACH_ENTRY(p, &hw->fl_profs[blk], ice_flow_prof, l_entry)
1549                 if ((p->dir == dir || conds & ICE_FLOW_FIND_PROF_NOT_CHK_DIR) &&
1550                     segs_cnt && segs_cnt == p->segs_cnt) {
1551                         u8 i;
1552
1553                         /* Check for profile-VSI association if specified */
1554                         if ((conds & ICE_FLOW_FIND_PROF_CHK_VSI) &&
1555                             ice_is_vsi_valid(hw, vsi_handle) &&
1556                             !ice_is_bit_set(p->vsis, vsi_handle))
1557                                 continue;
1558
1559                         /* Protocol headers must be checked. Matched fields are
1560                          * checked if specified.
1561                          */
1562                         for (i = 0; i < segs_cnt; i++)
1563                                 if (segs[i].hdrs != p->segs[i].hdrs ||
1564                                     ((conds & ICE_FLOW_FIND_PROF_CHK_FLDS) &&
1565                                      segs[i].match != p->segs[i].match))
1566                                         break;
1567
1568                         /* A match is found if all segments are matched */
1569                         if (i == segs_cnt) {
1570                                 prof = p;
1571                                 break;
1572                         }
1573                 }
1574         ice_release_lock(&hw->fl_profs_locks[blk]);
1575
1576         return prof;
1577 }
1578
1579 /**
1580  * ice_flow_find_prof - Look up a profile matching headers and matched fields
1581  * @hw: pointer to the HW struct
1582  * @blk: classification stage
1583  * @dir: flow direction
1584  * @segs: array of one or more packet segments that describe the flow
1585  * @segs_cnt: number of packet segments provided
1586  */
1587 u64
1588 ice_flow_find_prof(struct ice_hw *hw, enum ice_block blk, enum ice_flow_dir dir,
1589                    struct ice_flow_seg_info *segs, u8 segs_cnt)
1590 {
1591         struct ice_flow_prof *p;
1592
1593         p = ice_flow_find_prof_conds(hw, blk, dir, segs, segs_cnt,
1594                                      ICE_MAX_VSI, ICE_FLOW_FIND_PROF_CHK_FLDS);
1595
1596         return p ? p->id : ICE_FLOW_PROF_ID_INVAL;
1597 }
1598
1599 /**
1600  * ice_flow_find_prof_id - Look up a profile with given profile ID
1601  * @hw: pointer to the HW struct
1602  * @blk: classification stage
1603  * @prof_id: unique ID to identify this flow profile
1604  */
1605 static struct ice_flow_prof *
1606 ice_flow_find_prof_id(struct ice_hw *hw, enum ice_block blk, u64 prof_id)
1607 {
1608         struct ice_flow_prof *p;
1609
1610         LIST_FOR_EACH_ENTRY(p, &hw->fl_profs[blk], ice_flow_prof, l_entry)
1611                 if (p->id == prof_id)
1612                         return p;
1613
1614         return NULL;
1615 }
1616
1617 /**
1618  * ice_dealloc_flow_entry - Deallocate flow entry memory
1619  * @hw: pointer to the HW struct
1620  * @entry: flow entry to be removed
1621  */
1622 static void
1623 ice_dealloc_flow_entry(struct ice_hw *hw, struct ice_flow_entry *entry)
1624 {
1625         if (!entry)
1626                 return;
1627
1628         if (entry->entry)
1629                 ice_free(hw, entry->entry);
1630
1631         if (entry->range_buf) {
1632                 ice_free(hw, entry->range_buf);
1633                 entry->range_buf = NULL;
1634         }
1635
1636         if (entry->acts) {
1637                 ice_free(hw, entry->acts);
1638                 entry->acts = NULL;
1639                 entry->acts_cnt = 0;
1640         }
1641
1642         ice_free(hw, entry);
1643 }
1644
1645 #define ICE_ACL_INVALID_SCEN    0x3f
1646
1647 /**
1648  * ice_flow_acl_is_prof_in_use - Verify if the profile is associated to any PF
1649  * @hw: pointer to the hardware structure
1650  * @prof: pointer to flow profile
1651  * @buf: destination buffer function writes partial extraction sequence to
1652  *
1653  * returns ICE_SUCCESS if no PF is associated to the given profile
1654  * returns ICE_ERR_IN_USE if at least one PF is associated to the given profile
1655  * returns other error code for real error
1656  */
1657 static enum ice_status
1658 ice_flow_acl_is_prof_in_use(struct ice_hw *hw, struct ice_flow_prof *prof,
1659                             struct ice_aqc_acl_prof_generic_frmt *buf)
1660 {
1661         enum ice_status status;
1662         u8 prof_id = 0;
1663
1664         status = ice_flow_get_hw_prof(hw, ICE_BLK_ACL, prof->id, &prof_id);
1665         if (status)
1666                 return status;
1667
1668         status = ice_query_acl_prof(hw, prof_id, buf, NULL);
1669         if (status)
1670                 return status;
1671
1672         /* If all PF's associated scenarios are all 0 or all
1673          * ICE_ACL_INVALID_SCEN (63) for the given profile then the latter has
1674          * not been configured yet.
1675          */
1676         if (buf->pf_scenario_num[0] == 0 && buf->pf_scenario_num[1] == 0 &&
1677             buf->pf_scenario_num[2] == 0 && buf->pf_scenario_num[3] == 0 &&
1678             buf->pf_scenario_num[4] == 0 && buf->pf_scenario_num[5] == 0 &&
1679             buf->pf_scenario_num[6] == 0 && buf->pf_scenario_num[7] == 0)
1680                 return ICE_SUCCESS;
1681
1682         if (buf->pf_scenario_num[0] == ICE_ACL_INVALID_SCEN &&
1683             buf->pf_scenario_num[1] == ICE_ACL_INVALID_SCEN &&
1684             buf->pf_scenario_num[2] == ICE_ACL_INVALID_SCEN &&
1685             buf->pf_scenario_num[3] == ICE_ACL_INVALID_SCEN &&
1686             buf->pf_scenario_num[4] == ICE_ACL_INVALID_SCEN &&
1687             buf->pf_scenario_num[5] == ICE_ACL_INVALID_SCEN &&
1688             buf->pf_scenario_num[6] == ICE_ACL_INVALID_SCEN &&
1689             buf->pf_scenario_num[7] == ICE_ACL_INVALID_SCEN)
1690                 return ICE_SUCCESS;
1691         else
1692                 return ICE_ERR_IN_USE;
1693 }
1694
1695 /**
1696  * ice_flow_acl_free_act_cntr - Free the ACL rule's actions
1697  * @hw: pointer to the hardware structure
1698  * @acts: array of actions to be performed on a match
1699  * @acts_cnt: number of actions
1700  */
1701 static enum ice_status
1702 ice_flow_acl_free_act_cntr(struct ice_hw *hw, struct ice_flow_action *acts,
1703                            u8 acts_cnt)
1704 {
1705         int i;
1706
1707         for (i = 0; i < acts_cnt; i++) {
1708                 if (acts[i].type == ICE_FLOW_ACT_CNTR_PKT ||
1709                     acts[i].type == ICE_FLOW_ACT_CNTR_BYTES ||
1710                     acts[i].type == ICE_FLOW_ACT_CNTR_PKT_BYTES) {
1711                         struct ice_acl_cntrs cntrs;
1712                         enum ice_status status;
1713
1714                         cntrs.bank = 0; /* Only bank0 for the moment */
1715                         cntrs.first_cntr =
1716                                         LE16_TO_CPU(acts[i].data.acl_act.value);
1717                         cntrs.last_cntr =
1718                                         LE16_TO_CPU(acts[i].data.acl_act.value);
1719
1720                         if (acts[i].type == ICE_FLOW_ACT_CNTR_PKT_BYTES)
1721                                 cntrs.type = ICE_AQC_ACL_CNT_TYPE_DUAL;
1722                         else
1723                                 cntrs.type = ICE_AQC_ACL_CNT_TYPE_SINGLE;
1724
1725                         status = ice_aq_dealloc_acl_cntrs(hw, &cntrs, NULL);
1726                         if (status)
1727                                 return status;
1728                 }
1729         }
1730         return ICE_SUCCESS;
1731 }
1732
1733 /**
1734  * ice_flow_acl_disassoc_scen - Disassociate the scenario from the profile
1735  * @hw: pointer to the hardware structure
1736  * @prof: pointer to flow profile
1737  *
1738  * Disassociate the scenario from the profile for the PF of the VSI.
1739  */
1740 static enum ice_status
1741 ice_flow_acl_disassoc_scen(struct ice_hw *hw, struct ice_flow_prof *prof)
1742 {
1743         struct ice_aqc_acl_prof_generic_frmt buf;
1744         enum ice_status status = ICE_SUCCESS;
1745         u8 prof_id = 0;
1746
1747         ice_memset(&buf, 0, sizeof(buf), ICE_NONDMA_MEM);
1748
1749         status = ice_flow_get_hw_prof(hw, ICE_BLK_ACL, prof->id, &prof_id);
1750         if (status)
1751                 return status;
1752
1753         status = ice_query_acl_prof(hw, prof_id, &buf, NULL);
1754         if (status)
1755                 return status;
1756
1757         /* Clear scenario for this PF */
1758         buf.pf_scenario_num[hw->pf_id] = ICE_ACL_INVALID_SCEN;
1759         status = ice_prgm_acl_prof_extrt(hw, prof_id, &buf, NULL);
1760
1761         return status;
1762 }
1763
1764 /**
1765  * ice_flow_rem_entry_sync - Remove a flow entry
1766  * @hw: pointer to the HW struct
1767  * @blk: classification stage
1768  * @entry: flow entry to be removed
1769  */
1770 static enum ice_status
1771 ice_flow_rem_entry_sync(struct ice_hw *hw, enum ice_block blk,
1772                         struct ice_flow_entry *entry)
1773 {
1774         if (!entry)
1775                 return ICE_ERR_BAD_PTR;
1776
1777         if (blk == ICE_BLK_ACL) {
1778                 enum ice_status status;
1779
1780                 if (!entry->prof)
1781                         return ICE_ERR_BAD_PTR;
1782
1783                 status = ice_acl_rem_entry(hw, entry->prof->cfg.scen,
1784                                            entry->scen_entry_idx);
1785                 if (status)
1786                         return status;
1787
1788                 /* Checks if we need to release an ACL counter. */
1789                 if (entry->acts_cnt && entry->acts)
1790                         ice_flow_acl_free_act_cntr(hw, entry->acts,
1791                                                    entry->acts_cnt);
1792         }
1793
1794         LIST_DEL(&entry->l_entry);
1795
1796         ice_dealloc_flow_entry(hw, entry);
1797
1798         return ICE_SUCCESS;
1799 }
1800
1801 /**
1802  * ice_flow_add_prof_sync - Add a flow profile for packet segments and fields
1803  * @hw: pointer to the HW struct
1804  * @blk: classification stage
1805  * @dir: flow direction
1806  * @prof_id: unique ID to identify this flow profile
1807  * @segs: array of one or more packet segments that describe the flow
1808  * @segs_cnt: number of packet segments provided
1809  * @acts: array of default actions
1810  * @acts_cnt: number of default actions
1811  * @prof: stores the returned flow profile added
1812  *
1813  * Assumption: the caller has acquired the lock to the profile list
1814  */
1815 static enum ice_status
1816 ice_flow_add_prof_sync(struct ice_hw *hw, enum ice_block blk,
1817                        enum ice_flow_dir dir, u64 prof_id,
1818                        struct ice_flow_seg_info *segs, u8 segs_cnt,
1819                        struct ice_flow_action *acts, u8 acts_cnt,
1820                        struct ice_flow_prof **prof)
1821 {
1822         struct ice_flow_prof_params *params;
1823         enum ice_status status;
1824         u8 i;
1825
1826         if (!prof || (acts_cnt && !acts))
1827                 return ICE_ERR_BAD_PTR;
1828
1829         params = (struct ice_flow_prof_params *)ice_malloc(hw, sizeof(*params));
1830         if (!params)
1831                 return ICE_ERR_NO_MEMORY;
1832
1833         params->prof = (struct ice_flow_prof *)
1834                 ice_malloc(hw, sizeof(*params->prof));
1835         if (!params->prof) {
1836                 status = ICE_ERR_NO_MEMORY;
1837                 goto free_params;
1838         }
1839
1840         /* initialize extraction sequence to all invalid (0xff) */
1841         for (i = 0; i < ICE_MAX_FV_WORDS; i++) {
1842                 params->es[i].prot_id = ICE_PROT_INVALID;
1843                 params->es[i].off = ICE_FV_OFFSET_INVAL;
1844         }
1845
1846         params->blk = blk;
1847         params->prof->id = prof_id;
1848         params->prof->dir = dir;
1849         params->prof->segs_cnt = segs_cnt;
1850
1851         /* Make a copy of the segments that need to be persistent in the flow
1852          * profile instance
1853          */
1854         for (i = 0; i < segs_cnt; i++)
1855                 ice_memcpy(&params->prof->segs[i], &segs[i], sizeof(*segs),
1856                            ICE_NONDMA_TO_NONDMA);
1857
1858         /* Make a copy of the actions that need to be persistent in the flow
1859          * profile instance.
1860          */
1861         if (acts_cnt) {
1862                 params->prof->acts = (struct ice_flow_action *)
1863                         ice_memdup(hw, acts, acts_cnt * sizeof(*acts),
1864                                    ICE_NONDMA_TO_NONDMA);
1865
1866                 if (!params->prof->acts) {
1867                         status = ICE_ERR_NO_MEMORY;
1868                         goto out;
1869                 }
1870         }
1871
1872         status = ice_flow_proc_segs(hw, params);
1873         if (status) {
1874                 ice_debug(hw, ICE_DBG_FLOW, "Error processing a flow's packet segments\n");
1875                 goto out;
1876         }
1877
1878         /* Add a HW profile for this flow profile */
1879         status = ice_add_prof(hw, blk, prof_id, (u8 *)params->ptypes,
1880                               params->attr, params->attr_cnt, params->es,
1881                               params->mask);
1882         if (status) {
1883                 ice_debug(hw, ICE_DBG_FLOW, "Error adding a HW flow profile\n");
1884                 goto out;
1885         }
1886
1887         INIT_LIST_HEAD(&params->prof->entries);
1888         ice_init_lock(&params->prof->entries_lock);
1889         *prof = params->prof;
1890
1891 out:
1892         if (status) {
1893                 if (params->prof->acts)
1894                         ice_free(hw, params->prof->acts);
1895                 ice_free(hw, params->prof);
1896         }
1897 free_params:
1898         ice_free(hw, params);
1899
1900         return status;
1901 }
1902
1903 /**
1904  * ice_flow_rem_prof_sync - remove a flow profile
1905  * @hw: pointer to the hardware structure
1906  * @blk: classification stage
1907  * @prof: pointer to flow profile to remove
1908  *
1909  * Assumption: the caller has acquired the lock to the profile list
1910  */
1911 static enum ice_status
1912 ice_flow_rem_prof_sync(struct ice_hw *hw, enum ice_block blk,
1913                        struct ice_flow_prof *prof)
1914 {
1915         enum ice_status status;
1916
1917         /* Remove all remaining flow entries before removing the flow profile */
1918         if (!LIST_EMPTY(&prof->entries)) {
1919                 struct ice_flow_entry *e, *t;
1920
1921                 ice_acquire_lock(&prof->entries_lock);
1922
1923                 LIST_FOR_EACH_ENTRY_SAFE(e, t, &prof->entries, ice_flow_entry,
1924                                          l_entry) {
1925                         status = ice_flow_rem_entry_sync(hw, blk, e);
1926                         if (status)
1927                                 break;
1928                 }
1929
1930                 ice_release_lock(&prof->entries_lock);
1931         }
1932
1933         if (blk == ICE_BLK_ACL) {
1934                 struct ice_aqc_acl_profile_ranges query_rng_buf;
1935                 struct ice_aqc_acl_prof_generic_frmt buf;
1936                 u8 prof_id = 0;
1937
1938                 /* Disassociate the scenario from the profile for the PF */
1939                 status = ice_flow_acl_disassoc_scen(hw, prof);
1940                 if (status)
1941                         return status;
1942
1943                 /* Clear the range-checker if the profile ID is no longer
1944                  * used by any PF
1945                  */
1946                 status = ice_flow_acl_is_prof_in_use(hw, prof, &buf);
1947                 if (status && status != ICE_ERR_IN_USE) {
1948                         return status;
1949                 } else if (!status) {
1950                         /* Clear the range-checker value for profile ID */
1951                         ice_memset(&query_rng_buf, 0,
1952                                    sizeof(struct ice_aqc_acl_profile_ranges),
1953                                    ICE_NONDMA_MEM);
1954
1955                         status = ice_flow_get_hw_prof(hw, blk, prof->id,
1956                                                       &prof_id);
1957                         if (status)
1958                                 return status;
1959
1960                         status = ice_prog_acl_prof_ranges(hw, prof_id,
1961                                                           &query_rng_buf, NULL);
1962                         if (status)
1963                                 return status;
1964                 }
1965         }
1966
1967         /* Remove all hardware profiles associated with this flow profile */
1968         status = ice_rem_prof(hw, blk, prof->id);
1969         if (!status) {
1970                 LIST_DEL(&prof->l_entry);
1971                 ice_destroy_lock(&prof->entries_lock);
1972                 if (prof->acts)
1973                         ice_free(hw, prof->acts);
1974                 ice_free(hw, prof);
1975         }
1976
1977         return status;
1978 }
1979
1980 /**
1981  * ice_flow_acl_set_xtrct_seq_fld - Populate xtrct seq for single field
1982  * @buf: Destination buffer function writes partial xtrct sequence to
1983  * @info: Info about field
1984  */
1985 static void
1986 ice_flow_acl_set_xtrct_seq_fld(struct ice_aqc_acl_prof_generic_frmt *buf,
1987                                struct ice_flow_fld_info *info)
1988 {
1989         u16 dst, i;
1990         u8 src;
1991
1992         src = info->xtrct.idx * ICE_FLOW_FV_EXTRACT_SZ +
1993                 info->xtrct.disp / BITS_PER_BYTE;
1994         dst = info->entry.val;
1995         for (i = 0; i < info->entry.last; i++)
1996                 /* HW stores field vector words in LE, convert words back to BE
1997                  * so constructed entries will end up in network order
1998                  */
1999                 buf->byte_selection[dst++] = src++ ^ 1;
2000 }
2001
2002 /**
2003  * ice_flow_acl_set_xtrct_seq - Program ACL extraction sequence
2004  * @hw: pointer to the hardware structure
2005  * @prof: pointer to flow profile
2006  */
2007 static enum ice_status
2008 ice_flow_acl_set_xtrct_seq(struct ice_hw *hw, struct ice_flow_prof *prof)
2009 {
2010         struct ice_aqc_acl_prof_generic_frmt buf;
2011         struct ice_flow_fld_info *info;
2012         enum ice_status status;
2013         u8 prof_id = 0;
2014         u16 i;
2015
2016         ice_memset(&buf, 0, sizeof(buf), ICE_NONDMA_MEM);
2017
2018         status = ice_flow_get_hw_prof(hw, ICE_BLK_ACL, prof->id, &prof_id);
2019         if (status)
2020                 return status;
2021
2022         status = ice_flow_acl_is_prof_in_use(hw, prof, &buf);
2023         if (status && status != ICE_ERR_IN_USE)
2024                 return status;
2025
2026         if (!status) {
2027                 /* Program the profile dependent configuration. This is done
2028                  * only once regardless of the number of PFs using that profile
2029                  */
2030                 ice_memset(&buf, 0, sizeof(buf), ICE_NONDMA_MEM);
2031
2032                 for (i = 0; i < prof->segs_cnt; i++) {
2033                         struct ice_flow_seg_info *seg = &prof->segs[i];
2034                         u16 j;
2035
2036                         ice_for_each_set_bit(j, (ice_bitmap_t *)&seg->match,
2037                                              ICE_FLOW_FIELD_IDX_MAX) {
2038                                 info = &seg->fields[j];
2039
2040                                 if (info->type == ICE_FLOW_FLD_TYPE_RANGE)
2041                                         buf.word_selection[info->entry.val] =
2042                                                 info->xtrct.idx;
2043                                 else
2044                                         ice_flow_acl_set_xtrct_seq_fld(&buf,
2045                                                                        info);
2046                         }
2047
2048                         for (j = 0; j < seg->raws_cnt; j++) {
2049                                 info = &seg->raws[j].info;
2050                                 ice_flow_acl_set_xtrct_seq_fld(&buf, info);
2051                         }
2052                 }
2053
2054                 ice_memset(&buf.pf_scenario_num[0], ICE_ACL_INVALID_SCEN,
2055                            ICE_AQC_ACL_PROF_PF_SCEN_NUM_ELEMS,
2056                            ICE_NONDMA_MEM);
2057         }
2058
2059         /* Update the current PF */
2060         buf.pf_scenario_num[hw->pf_id] = (u8)prof->cfg.scen->id;
2061         status = ice_prgm_acl_prof_extrt(hw, prof_id, &buf, NULL);
2062
2063         return status;
2064 }
2065
2066 /**
2067  * ice_flow_assoc_vsig_vsi - associate a VSI with VSIG
2068  * @hw: pointer to the hardware structure
2069  * @blk: classification stage
2070  * @vsi_handle: software VSI handle
2071  * @vsig: target VSI group
2072  *
2073  * Assumption: the caller has already verified that the VSI to
2074  * be added has the same characteristics as the VSIG and will
2075  * thereby have access to all resources added to that VSIG.
2076  */
2077 enum ice_status
2078 ice_flow_assoc_vsig_vsi(struct ice_hw *hw, enum ice_block blk, u16 vsi_handle,
2079                         u16 vsig)
2080 {
2081         enum ice_status status;
2082
2083         if (!ice_is_vsi_valid(hw, vsi_handle) || blk >= ICE_BLK_COUNT)
2084                 return ICE_ERR_PARAM;
2085
2086         ice_acquire_lock(&hw->fl_profs_locks[blk]);
2087         status = ice_add_vsi_flow(hw, blk, ice_get_hw_vsi_num(hw, vsi_handle),
2088                                   vsig);
2089         ice_release_lock(&hw->fl_profs_locks[blk]);
2090
2091         return status;
2092 }
2093
2094 /**
2095  * ice_flow_assoc_prof - associate a VSI with a flow profile
2096  * @hw: pointer to the hardware structure
2097  * @blk: classification stage
2098  * @prof: pointer to flow profile
2099  * @vsi_handle: software VSI handle
2100  *
2101  * Assumption: the caller has acquired the lock to the profile list
2102  * and the software VSI handle has been validated
2103  */
2104 static enum ice_status
2105 ice_flow_assoc_prof(struct ice_hw *hw, enum ice_block blk,
2106                     struct ice_flow_prof *prof, u16 vsi_handle)
2107 {
2108         enum ice_status status = ICE_SUCCESS;
2109
2110         if (!ice_is_bit_set(prof->vsis, vsi_handle)) {
2111                 if (blk == ICE_BLK_ACL) {
2112                         status = ice_flow_acl_set_xtrct_seq(hw, prof);
2113                         if (status)
2114                                 return status;
2115                 }
2116                 status = ice_add_prof_id_flow(hw, blk,
2117                                               ice_get_hw_vsi_num(hw,
2118                                                                  vsi_handle),
2119                                               prof->id);
2120                 if (!status)
2121                         ice_set_bit(vsi_handle, prof->vsis);
2122                 else
2123                         ice_debug(hw, ICE_DBG_FLOW, "HW profile add failed, %d\n",
2124                                   status);
2125         }
2126
2127         return status;
2128 }
2129
2130 /**
2131  * ice_flow_disassoc_prof - disassociate a VSI from a flow profile
2132  * @hw: pointer to the hardware structure
2133  * @blk: classification stage
2134  * @prof: pointer to flow profile
2135  * @vsi_handle: software VSI handle
2136  *
2137  * Assumption: the caller has acquired the lock to the profile list
2138  * and the software VSI handle has been validated
2139  */
2140 static enum ice_status
2141 ice_flow_disassoc_prof(struct ice_hw *hw, enum ice_block blk,
2142                        struct ice_flow_prof *prof, u16 vsi_handle)
2143 {
2144         enum ice_status status = ICE_SUCCESS;
2145
2146         if (ice_is_bit_set(prof->vsis, vsi_handle)) {
2147                 status = ice_rem_prof_id_flow(hw, blk,
2148                                               ice_get_hw_vsi_num(hw,
2149                                                                  vsi_handle),
2150                                               prof->id);
2151                 if (!status)
2152                         ice_clear_bit(vsi_handle, prof->vsis);
2153                 else
2154                         ice_debug(hw, ICE_DBG_FLOW, "HW profile remove failed, %d\n",
2155                                   status);
2156         }
2157
2158         return status;
2159 }
2160
2161 /**
2162  * ice_flow_add_prof - Add a flow profile for packet segments and matched fields
2163  * @hw: pointer to the HW struct
2164  * @blk: classification stage
2165  * @dir: flow direction
2166  * @prof_id: unique ID to identify this flow profile
2167  * @segs: array of one or more packet segments that describe the flow
2168  * @segs_cnt: number of packet segments provided
2169  * @acts: array of default actions
2170  * @acts_cnt: number of default actions
2171  * @prof: stores the returned flow profile added
2172  */
2173 enum ice_status
2174 ice_flow_add_prof(struct ice_hw *hw, enum ice_block blk, enum ice_flow_dir dir,
2175                   u64 prof_id, struct ice_flow_seg_info *segs, u8 segs_cnt,
2176                   struct ice_flow_action *acts, u8 acts_cnt,
2177                   struct ice_flow_prof **prof)
2178 {
2179         enum ice_status status;
2180
2181         if (segs_cnt > ICE_FLOW_SEG_MAX)
2182                 return ICE_ERR_MAX_LIMIT;
2183
2184         if (!segs_cnt)
2185                 return ICE_ERR_PARAM;
2186
2187         if (!segs)
2188                 return ICE_ERR_BAD_PTR;
2189
2190         status = ice_flow_val_hdrs(segs, segs_cnt);
2191         if (status)
2192                 return status;
2193
2194         ice_acquire_lock(&hw->fl_profs_locks[blk]);
2195
2196         status = ice_flow_add_prof_sync(hw, blk, dir, prof_id, segs, segs_cnt,
2197                                         acts, acts_cnt, prof);
2198         if (!status)
2199                 LIST_ADD(&(*prof)->l_entry, &hw->fl_profs[blk]);
2200
2201         ice_release_lock(&hw->fl_profs_locks[blk]);
2202
2203         return status;
2204 }
2205
2206 /**
2207  * ice_flow_rem_prof - Remove a flow profile and all entries associated with it
2208  * @hw: pointer to the HW struct
2209  * @blk: the block for which the flow profile is to be removed
2210  * @prof_id: unique ID of the flow profile to be removed
2211  */
2212 enum ice_status
2213 ice_flow_rem_prof(struct ice_hw *hw, enum ice_block blk, u64 prof_id)
2214 {
2215         struct ice_flow_prof *prof;
2216         enum ice_status status;
2217
2218         ice_acquire_lock(&hw->fl_profs_locks[blk]);
2219
2220         prof = ice_flow_find_prof_id(hw, blk, prof_id);
2221         if (!prof) {
2222                 status = ICE_ERR_DOES_NOT_EXIST;
2223                 goto out;
2224         }
2225
2226         /* prof becomes invalid after the call */
2227         status = ice_flow_rem_prof_sync(hw, blk, prof);
2228
2229 out:
2230         ice_release_lock(&hw->fl_profs_locks[blk]);
2231
2232         return status;
2233 }
2234
2235 /**
2236  * ice_flow_get_hw_prof - return the HW profile for a specific profile ID handle
2237  * @hw: pointer to the HW struct
2238  * @blk: classification stage
2239  * @prof_id: the profile ID handle
2240  * @hw_prof_id: pointer to variable to receive the HW profile ID
2241  */
2242 enum ice_status
2243 ice_flow_get_hw_prof(struct ice_hw *hw, enum ice_block blk, u64 prof_id,
2244                      u8 *hw_prof_id)
2245 {
2246         enum ice_status status = ICE_ERR_DOES_NOT_EXIST;
2247         struct ice_prof_map *map;
2248
2249         ice_acquire_lock(&hw->blk[blk].es.prof_map_lock);
2250         map = ice_search_prof_id(hw, blk, prof_id);
2251         if (map) {
2252                 *hw_prof_id = map->prof_id;
2253                 status = ICE_SUCCESS;
2254         }
2255         ice_release_lock(&hw->blk[blk].es.prof_map_lock);
2256         return status;
2257 }
2258
2259 /**
2260  * ice_flow_find_entry - look for a flow entry using its unique ID
2261  * @hw: pointer to the HW struct
2262  * @blk: classification stage
2263  * @entry_id: unique ID to identify this flow entry
2264  *
2265  * This function looks for the flow entry with the specified unique ID in all
2266  * flow profiles of the specified classification stage. If the entry is found,
2267  * and it returns the handle to the flow entry. Otherwise, it returns
2268  * ICE_FLOW_ENTRY_ID_INVAL.
2269  */
2270 u64 ice_flow_find_entry(struct ice_hw *hw, enum ice_block blk, u64 entry_id)
2271 {
2272         struct ice_flow_entry *found = NULL;
2273         struct ice_flow_prof *p;
2274
2275         ice_acquire_lock(&hw->fl_profs_locks[blk]);
2276
2277         LIST_FOR_EACH_ENTRY(p, &hw->fl_profs[blk], ice_flow_prof, l_entry) {
2278                 struct ice_flow_entry *e;
2279
2280                 ice_acquire_lock(&p->entries_lock);
2281                 LIST_FOR_EACH_ENTRY(e, &p->entries, ice_flow_entry, l_entry)
2282                         if (e->id == entry_id) {
2283                                 found = e;
2284                                 break;
2285                         }
2286                 ice_release_lock(&p->entries_lock);
2287
2288                 if (found)
2289                         break;
2290         }
2291
2292         ice_release_lock(&hw->fl_profs_locks[blk]);
2293
2294         return found ? ICE_FLOW_ENTRY_HNDL(found) : ICE_FLOW_ENTRY_HANDLE_INVAL;
2295 }
2296
2297 /**
2298  * ice_flow_acl_check_actions - Checks the ACL rule's actions
2299  * @hw: pointer to the hardware structure
2300  * @acts: array of actions to be performed on a match
2301  * @acts_cnt: number of actions
2302  * @cnt_alloc: indicates if an ACL counter has been allocated.
2303  */
2304 static enum ice_status
2305 ice_flow_acl_check_actions(struct ice_hw *hw, struct ice_flow_action *acts,
2306                            u8 acts_cnt, bool *cnt_alloc)
2307 {
2308         ice_declare_bitmap(dup_check, ICE_AQC_TBL_MAX_ACTION_PAIRS * 2);
2309         int i;
2310
2311         ice_zero_bitmap(dup_check, ICE_AQC_TBL_MAX_ACTION_PAIRS * 2);
2312         *cnt_alloc = false;
2313
2314         if (acts_cnt > ICE_FLOW_ACL_MAX_NUM_ACT)
2315                 return ICE_ERR_OUT_OF_RANGE;
2316
2317         for (i = 0; i < acts_cnt; i++) {
2318                 if (acts[i].type != ICE_FLOW_ACT_NOP &&
2319                     acts[i].type != ICE_FLOW_ACT_DROP &&
2320                     acts[i].type != ICE_FLOW_ACT_CNTR_PKT &&
2321                     acts[i].type != ICE_FLOW_ACT_FWD_QUEUE)
2322                         return ICE_ERR_CFG;
2323
2324                 /* If the caller want to add two actions of the same type, then
2325                  * it is considered invalid configuration.
2326                  */
2327                 if (ice_test_and_set_bit(acts[i].type, dup_check))
2328                         return ICE_ERR_PARAM;
2329         }
2330
2331         /* Checks if ACL counters are needed. */
2332         for (i = 0; i < acts_cnt; i++) {
2333                 if (acts[i].type == ICE_FLOW_ACT_CNTR_PKT ||
2334                     acts[i].type == ICE_FLOW_ACT_CNTR_BYTES ||
2335                     acts[i].type == ICE_FLOW_ACT_CNTR_PKT_BYTES) {
2336                         struct ice_acl_cntrs cntrs;
2337                         enum ice_status status;
2338
2339                         cntrs.amount = 1;
2340                         cntrs.bank = 0; /* Only bank0 for the moment */
2341
2342                         if (acts[i].type == ICE_FLOW_ACT_CNTR_PKT_BYTES)
2343                                 cntrs.type = ICE_AQC_ACL_CNT_TYPE_DUAL;
2344                         else
2345                                 cntrs.type = ICE_AQC_ACL_CNT_TYPE_SINGLE;
2346
2347                         status = ice_aq_alloc_acl_cntrs(hw, &cntrs, NULL);
2348                         if (status)
2349                                 return status;
2350                         /* Counter index within the bank */
2351                         acts[i].data.acl_act.value =
2352                                                 CPU_TO_LE16(cntrs.first_cntr);
2353                         *cnt_alloc = true;
2354                 }
2355         }
2356
2357         return ICE_SUCCESS;
2358 }
2359
2360 /**
2361  * ice_flow_acl_frmt_entry_range - Format an ACL range checker for a given field
2362  * @fld: number of the given field
2363  * @info: info about field
2364  * @range_buf: range checker configuration buffer
2365  * @data: pointer to a data buffer containing flow entry's match values/masks
2366  * @range: Input/output param indicating which range checkers are being used
2367  */
2368 static void
2369 ice_flow_acl_frmt_entry_range(u16 fld, struct ice_flow_fld_info *info,
2370                               struct ice_aqc_acl_profile_ranges *range_buf,
2371                               u8 *data, u8 *range)
2372 {
2373         u16 new_mask;
2374
2375         /* If not specified, default mask is all bits in field */
2376         new_mask = (info->src.mask == ICE_FLOW_FLD_OFF_INVAL ?
2377                     BIT(ice_flds_info[fld].size) - 1 :
2378                     (*(u16 *)(data + info->src.mask))) << info->xtrct.disp;
2379
2380         /* If the mask is 0, then we don't need to worry about this input
2381          * range checker value.
2382          */
2383         if (new_mask) {
2384                 u16 new_high =
2385                         (*(u16 *)(data + info->src.last)) << info->xtrct.disp;
2386                 u16 new_low =
2387                         (*(u16 *)(data + info->src.val)) << info->xtrct.disp;
2388                 u8 range_idx = info->entry.val;
2389
2390                 range_buf->checker_cfg[range_idx].low_boundary =
2391                         CPU_TO_BE16(new_low);
2392                 range_buf->checker_cfg[range_idx].high_boundary =
2393                         CPU_TO_BE16(new_high);
2394                 range_buf->checker_cfg[range_idx].mask = CPU_TO_BE16(new_mask);
2395
2396                 /* Indicate which range checker is being used */
2397                 *range |= BIT(range_idx);
2398         }
2399 }
2400
2401 /**
2402  * ice_flow_acl_frmt_entry_fld - Partially format ACL entry for a given field
2403  * @fld: number of the given field
2404  * @info: info about the field
2405  * @buf: buffer containing the entry
2406  * @dontcare: buffer containing don't care mask for entry
2407  * @data: pointer to a data buffer containing flow entry's match values/masks
2408  */
2409 static void
2410 ice_flow_acl_frmt_entry_fld(u16 fld, struct ice_flow_fld_info *info, u8 *buf,
2411                             u8 *dontcare, u8 *data)
2412 {
2413         u16 dst, src, mask, k, end_disp, tmp_s = 0, tmp_m = 0;
2414         bool use_mask = false;
2415         u8 disp;
2416
2417         src = info->src.val;
2418         mask = info->src.mask;
2419         dst = info->entry.val - ICE_AQC_ACL_PROF_BYTE_SEL_START_IDX;
2420         disp = info->xtrct.disp % BITS_PER_BYTE;
2421
2422         if (mask != ICE_FLOW_FLD_OFF_INVAL)
2423                 use_mask = true;
2424
2425         for (k = 0; k < info->entry.last; k++, dst++) {
2426                 /* Add overflow bits from previous byte */
2427                 buf[dst] = (tmp_s & 0xff00) >> 8;
2428
2429                 /* If mask is not valid, tmp_m is always zero, so just setting
2430                  * dontcare to 0 (no masked bits). If mask is valid, pulls in
2431                  * overflow bits of mask from prev byte
2432                  */
2433                 dontcare[dst] = (tmp_m & 0xff00) >> 8;
2434
2435                 /* If there is displacement, last byte will only contain
2436                  * displaced data, but there is no more data to read from user
2437                  * buffer, so skip so as not to potentially read beyond end of
2438                  * user buffer
2439                  */
2440                 if (!disp || k < info->entry.last - 1) {
2441                         /* Store shifted data to use in next byte */
2442                         tmp_s = data[src++] << disp;
2443
2444                         /* Add current (shifted) byte */
2445                         buf[dst] |= tmp_s & 0xff;
2446
2447                         /* Handle mask if valid */
2448                         if (use_mask) {
2449                                 tmp_m = (~data[mask++] & 0xff) << disp;
2450                                 dontcare[dst] |= tmp_m & 0xff;
2451                         }
2452                 }
2453         }
2454
2455         /* Fill in don't care bits at beginning of field */
2456         if (disp) {
2457                 dst = info->entry.val - ICE_AQC_ACL_PROF_BYTE_SEL_START_IDX;
2458                 for (k = 0; k < disp; k++)
2459                         dontcare[dst] |= BIT(k);
2460         }
2461
2462         end_disp = (disp + ice_flds_info[fld].size) % BITS_PER_BYTE;
2463
2464         /* Fill in don't care bits at end of field */
2465         if (end_disp) {
2466                 dst = info->entry.val - ICE_AQC_ACL_PROF_BYTE_SEL_START_IDX +
2467                       info->entry.last - 1;
2468                 for (k = end_disp; k < BITS_PER_BYTE; k++)
2469                         dontcare[dst] |= BIT(k);
2470         }
2471 }
2472
2473 /**
2474  * ice_flow_acl_frmt_entry - Format ACL entry
2475  * @hw: pointer to the hardware structure
2476  * @prof: pointer to flow profile
2477  * @e: pointer to the flow entry
2478  * @data: pointer to a data buffer containing flow entry's match values/masks
2479  * @acts: array of actions to be performed on a match
2480  * @acts_cnt: number of actions
2481  *
2482  * Formats the key (and key_inverse) to be matched from the data passed in,
2483  * along with data from the flow profile. This key/key_inverse pair makes up
2484  * the 'entry' for an ACL flow entry.
2485  */
2486 static enum ice_status
2487 ice_flow_acl_frmt_entry(struct ice_hw *hw, struct ice_flow_prof *prof,
2488                         struct ice_flow_entry *e, u8 *data,
2489                         struct ice_flow_action *acts, u8 acts_cnt)
2490 {
2491         u8 *buf = NULL, *dontcare = NULL, *key = NULL, range = 0, dir_flag_msk;
2492         struct ice_aqc_acl_profile_ranges *range_buf = NULL;
2493         enum ice_status status;
2494         bool cnt_alloc;
2495         u8 prof_id = 0;
2496         u16 i, buf_sz;
2497
2498         status = ice_flow_get_hw_prof(hw, ICE_BLK_ACL, prof->id, &prof_id);
2499         if (status)
2500                 return status;
2501
2502         /* Format the result action */
2503
2504         status = ice_flow_acl_check_actions(hw, acts, acts_cnt, &cnt_alloc);
2505         if (status)
2506                 return status;
2507
2508         status = ICE_ERR_NO_MEMORY;
2509
2510         e->acts = (struct ice_flow_action *)
2511                 ice_memdup(hw, acts, acts_cnt * sizeof(*acts),
2512                            ICE_NONDMA_TO_NONDMA);
2513
2514         if (!e->acts)
2515                 goto out;
2516
2517         e->acts_cnt = acts_cnt;
2518
2519         /* Format the matching data */
2520         buf_sz = prof->cfg.scen->width;
2521         buf = (u8 *)ice_malloc(hw, buf_sz);
2522         if (!buf)
2523                 goto out;
2524
2525         dontcare = (u8 *)ice_malloc(hw, buf_sz);
2526         if (!dontcare)
2527                 goto out;
2528
2529         /* 'key' buffer will store both key and key_inverse, so must be twice
2530          * size of buf
2531          */
2532         key = (u8 *)ice_malloc(hw, buf_sz * 2);
2533         if (!key)
2534                 goto out;
2535
2536         range_buf = (struct ice_aqc_acl_profile_ranges *)
2537                 ice_malloc(hw, sizeof(struct ice_aqc_acl_profile_ranges));
2538         if (!range_buf)
2539                 goto out;
2540
2541         /* Set don't care mask to all 1's to start, will zero out used bytes */
2542         ice_memset(dontcare, 0xff, buf_sz, ICE_NONDMA_MEM);
2543
2544         for (i = 0; i < prof->segs_cnt; i++) {
2545                 struct ice_flow_seg_info *seg = &prof->segs[i];
2546                 u8 j;
2547
2548                 ice_for_each_set_bit(j, (ice_bitmap_t *)&seg->match,
2549                                      ICE_FLOW_FIELD_IDX_MAX) {
2550                         struct ice_flow_fld_info *info = &seg->fields[j];
2551
2552                         if (info->type == ICE_FLOW_FLD_TYPE_RANGE)
2553                                 ice_flow_acl_frmt_entry_range(j, info,
2554                                                               range_buf, data,
2555                                                               &range);
2556                         else
2557                                 ice_flow_acl_frmt_entry_fld(j, info, buf,
2558                                                             dontcare, data);
2559                 }
2560
2561                 for (j = 0; j < seg->raws_cnt; j++) {
2562                         struct ice_flow_fld_info *info = &seg->raws[j].info;
2563                         u16 dst, src, mask, k;
2564                         bool use_mask = false;
2565
2566                         src = info->src.val;
2567                         dst = info->entry.val -
2568                                         ICE_AQC_ACL_PROF_BYTE_SEL_START_IDX;
2569                         mask = info->src.mask;
2570
2571                         if (mask != ICE_FLOW_FLD_OFF_INVAL)
2572                                 use_mask = true;
2573
2574                         for (k = 0; k < info->entry.last; k++, dst++) {
2575                                 buf[dst] = data[src++];
2576                                 if (use_mask)
2577                                         dontcare[dst] = ~data[mask++];
2578                                 else
2579                                         dontcare[dst] = 0;
2580                         }
2581                 }
2582         }
2583
2584         buf[prof->cfg.scen->pid_idx] = (u8)prof_id;
2585         dontcare[prof->cfg.scen->pid_idx] = 0;
2586
2587         /* Format the buffer for direction flags */
2588         dir_flag_msk = BIT(ICE_FLG_PKT_DIR);
2589
2590         if (prof->dir == ICE_FLOW_RX)
2591                 buf[prof->cfg.scen->pkt_dir_idx] = dir_flag_msk;
2592
2593         if (range) {
2594                 buf[prof->cfg.scen->rng_chk_idx] = range;
2595                 /* Mark any unused range checkers as don't care */
2596                 dontcare[prof->cfg.scen->rng_chk_idx] = ~range;
2597                 e->range_buf = range_buf;
2598         } else {
2599                 ice_free(hw, range_buf);
2600         }
2601
2602         status = ice_set_key(key, buf_sz * 2, buf, NULL, dontcare, NULL, 0,
2603                              buf_sz);
2604         if (status)
2605                 goto out;
2606
2607         e->entry = key;
2608         e->entry_sz = buf_sz * 2;
2609
2610 out:
2611         if (buf)
2612                 ice_free(hw, buf);
2613
2614         if (dontcare)
2615                 ice_free(hw, dontcare);
2616
2617         if (status && key)
2618                 ice_free(hw, key);
2619
2620         if (status && range_buf) {
2621                 ice_free(hw, range_buf);
2622                 e->range_buf = NULL;
2623         }
2624
2625         if (status && e->acts) {
2626                 ice_free(hw, e->acts);
2627                 e->acts = NULL;
2628                 e->acts_cnt = 0;
2629         }
2630
2631         if (status && cnt_alloc)
2632                 ice_flow_acl_free_act_cntr(hw, acts, acts_cnt);
2633
2634         return status;
2635 }
2636
2637 /**
2638  * ice_flow_acl_find_scen_entry_cond - Find an ACL scenario entry that matches
2639  *                                     the compared data.
2640  * @prof: pointer to flow profile
2641  * @e: pointer to the comparing flow entry
2642  * @do_chg_action: decide if we want to change the ACL action
2643  * @do_add_entry: decide if we want to add the new ACL entry
2644  * @do_rem_entry: decide if we want to remove the current ACL entry
2645  *
2646  * Find an ACL scenario entry that matches the compared data. In the same time,
2647  * this function also figure out:
2648  * a/ If we want to change the ACL action
2649  * b/ If we want to add the new ACL entry
2650  * c/ If we want to remove the current ACL entry
2651  */
2652 static struct ice_flow_entry *
2653 ice_flow_acl_find_scen_entry_cond(struct ice_flow_prof *prof,
2654                                   struct ice_flow_entry *e, bool *do_chg_action,
2655                                   bool *do_add_entry, bool *do_rem_entry)
2656 {
2657         struct ice_flow_entry *p, *return_entry = NULL;
2658         u8 i, j;
2659
2660         /* Check if:
2661          * a/ There exists an entry with same matching data, but different
2662          *    priority, then we remove this existing ACL entry. Then, we
2663          *    will add the new entry to the ACL scenario.
2664          * b/ There exists an entry with same matching data, priority, and
2665          *    result action, then we do nothing
2666          * c/ There exists an entry with same matching data, priority, but
2667          *    different, action, then do only change the action's entry.
2668          * d/ Else, we add this new entry to the ACL scenario.
2669          */
2670         *do_chg_action = false;
2671         *do_add_entry = true;
2672         *do_rem_entry = false;
2673         LIST_FOR_EACH_ENTRY(p, &prof->entries, ice_flow_entry, l_entry) {
2674                 if (memcmp(p->entry, e->entry, p->entry_sz))
2675                         continue;
2676
2677                 /* From this point, we have the same matching_data. */
2678                 *do_add_entry = false;
2679                 return_entry = p;
2680
2681                 if (p->priority != e->priority) {
2682                         /* matching data && !priority */
2683                         *do_add_entry = true;
2684                         *do_rem_entry = true;
2685                         break;
2686                 }
2687
2688                 /* From this point, we will have matching_data && priority */
2689                 if (p->acts_cnt != e->acts_cnt)
2690                         *do_chg_action = true;
2691                 for (i = 0; i < p->acts_cnt; i++) {
2692                         bool found_not_match = false;
2693
2694                         for (j = 0; j < e->acts_cnt; j++)
2695                                 if (memcmp(&p->acts[i], &e->acts[j],
2696                                            sizeof(struct ice_flow_action))) {
2697                                         found_not_match = true;
2698                                         break;
2699                                 }
2700
2701                         if (found_not_match) {
2702                                 *do_chg_action = true;
2703                                 break;
2704                         }
2705                 }
2706
2707                 /* (do_chg_action = true) means :
2708                  *    matching_data && priority && !result_action
2709                  * (do_chg_action = false) means :
2710                  *    matching_data && priority && result_action
2711                  */
2712                 break;
2713         }
2714
2715         return return_entry;
2716 }
2717
2718 /**
2719  * ice_flow_acl_convert_to_acl_prior - Convert to ACL priority
2720  * @p: flow priority
2721  */
2722 static enum ice_acl_entry_prior
2723 ice_flow_acl_convert_to_acl_prior(enum ice_flow_priority p)
2724 {
2725         enum ice_acl_entry_prior acl_prior;
2726
2727         switch (p) {
2728         case ICE_FLOW_PRIO_LOW:
2729                 acl_prior = ICE_LOW;
2730                 break;
2731         case ICE_FLOW_PRIO_NORMAL:
2732                 acl_prior = ICE_NORMAL;
2733                 break;
2734         case ICE_FLOW_PRIO_HIGH:
2735                 acl_prior = ICE_HIGH;
2736                 break;
2737         default:
2738                 acl_prior = ICE_NORMAL;
2739                 break;
2740         }
2741
2742         return acl_prior;
2743 }
2744
2745 /**
2746  * ice_flow_acl_union_rng_chk - Perform union operation between two
2747  *                              range-range checker buffers
2748  * @dst_buf: pointer to destination range checker buffer
2749  * @src_buf: pointer to source range checker buffer
2750  *
2751  * For this function, we do the union between dst_buf and src_buf
2752  * range checker buffer, and we will save the result back to dst_buf
2753  */
2754 static enum ice_status
2755 ice_flow_acl_union_rng_chk(struct ice_aqc_acl_profile_ranges *dst_buf,
2756                            struct ice_aqc_acl_profile_ranges *src_buf)
2757 {
2758         u8 i, j;
2759
2760         if (!dst_buf || !src_buf)
2761                 return ICE_ERR_BAD_PTR;
2762
2763         for (i = 0; i < ICE_AQC_ACL_PROF_RANGES_NUM_CFG; i++) {
2764                 struct ice_acl_rng_data *cfg_data = NULL, *in_data;
2765                 bool will_populate = false;
2766
2767                 in_data = &src_buf->checker_cfg[i];
2768
2769                 if (!in_data->mask)
2770                         break;
2771
2772                 for (j = 0; j < ICE_AQC_ACL_PROF_RANGES_NUM_CFG; j++) {
2773                         cfg_data = &dst_buf->checker_cfg[j];
2774
2775                         if (!cfg_data->mask ||
2776                             !memcmp(cfg_data, in_data,
2777                                     sizeof(struct ice_acl_rng_data))) {
2778                                 will_populate = true;
2779                                 break;
2780                         }
2781                 }
2782
2783                 if (will_populate) {
2784                         ice_memcpy(cfg_data, in_data,
2785                                    sizeof(struct ice_acl_rng_data),
2786                                    ICE_NONDMA_TO_NONDMA);
2787                 } else {
2788                         /* No available slot left to program range checker */
2789                         return ICE_ERR_MAX_LIMIT;
2790                 }
2791         }
2792
2793         return ICE_SUCCESS;
2794 }
2795
2796 /**
2797  * ice_flow_acl_add_scen_entry_sync - Add entry to ACL scenario sync
2798  * @hw: pointer to the hardware structure
2799  * @prof: pointer to flow profile
2800  * @entry: double pointer to the flow entry
2801  *
2802  * For this function, we will look at the current added entries in the
2803  * corresponding ACL scenario. Then, we will perform matching logic to
2804  * see if we want to add/modify/do nothing with this new entry.
2805  */
2806 static enum ice_status
2807 ice_flow_acl_add_scen_entry_sync(struct ice_hw *hw, struct ice_flow_prof *prof,
2808                                  struct ice_flow_entry **entry)
2809 {
2810         bool do_add_entry, do_rem_entry, do_chg_action, do_chg_rng_chk;
2811         struct ice_aqc_acl_profile_ranges query_rng_buf, cfg_rng_buf;
2812         struct ice_acl_act_entry *acts = NULL;
2813         struct ice_flow_entry *exist;
2814         enum ice_status status = ICE_SUCCESS;
2815         struct ice_flow_entry *e;
2816         u8 i;
2817
2818         if (!entry || !(*entry) || !prof)
2819                 return ICE_ERR_BAD_PTR;
2820
2821         e = *(entry);
2822
2823         do_chg_rng_chk = false;
2824         if (e->range_buf) {
2825                 u8 prof_id = 0;
2826
2827                 status = ice_flow_get_hw_prof(hw, ICE_BLK_ACL, prof->id,
2828                                               &prof_id);
2829                 if (status)
2830                         return status;
2831
2832                 /* Query the current range-checker value in FW */
2833                 status = ice_query_acl_prof_ranges(hw, prof_id, &query_rng_buf,
2834                                                    NULL);
2835                 if (status)
2836                         return status;
2837                 ice_memcpy(&cfg_rng_buf, &query_rng_buf,
2838                            sizeof(struct ice_aqc_acl_profile_ranges),
2839                            ICE_NONDMA_TO_NONDMA);
2840
2841                 /* Generate the new range-checker value */
2842                 status = ice_flow_acl_union_rng_chk(&cfg_rng_buf, e->range_buf);
2843                 if (status)
2844                         return status;
2845
2846                 /* Reconfigure the range check if the buffer is changed. */
2847                 do_chg_rng_chk = false;
2848                 if (memcmp(&query_rng_buf, &cfg_rng_buf,
2849                            sizeof(struct ice_aqc_acl_profile_ranges))) {
2850                         status = ice_prog_acl_prof_ranges(hw, prof_id,
2851                                                           &cfg_rng_buf, NULL);
2852                         if (status)
2853                                 return status;
2854
2855                         do_chg_rng_chk = true;
2856                 }
2857         }
2858
2859         /* Figure out if we want to (change the ACL action) and/or
2860          * (Add the new ACL entry) and/or (Remove the current ACL entry)
2861          */
2862         exist = ice_flow_acl_find_scen_entry_cond(prof, e, &do_chg_action,
2863                                                   &do_add_entry, &do_rem_entry);
2864
2865         if (do_rem_entry) {
2866                 status = ice_flow_rem_entry_sync(hw, ICE_BLK_ACL, exist);
2867                 if (status)
2868                         return status;
2869         }
2870
2871         /* Prepare the result action buffer */
2872         acts = (struct ice_acl_act_entry *)ice_calloc
2873                 (hw, e->entry_sz, sizeof(struct ice_acl_act_entry));
2874         for (i = 0; i < e->acts_cnt; i++)
2875                 ice_memcpy(&acts[i], &e->acts[i].data.acl_act,
2876                            sizeof(struct ice_acl_act_entry),
2877                            ICE_NONDMA_TO_NONDMA);
2878
2879         if (do_add_entry) {
2880                 enum ice_acl_entry_prior prior;
2881                 u8 *keys, *inverts;
2882                 u16 entry_idx;
2883
2884                 keys = (u8 *)e->entry;
2885                 inverts = keys + (e->entry_sz / 2);
2886                 prior = ice_flow_acl_convert_to_acl_prior(e->priority);
2887
2888                 status = ice_acl_add_entry(hw, prof->cfg.scen, prior, keys,
2889                                            inverts, acts, e->acts_cnt,
2890                                            &entry_idx);
2891                 if (status)
2892                         goto out;
2893
2894                 e->scen_entry_idx = entry_idx;
2895                 LIST_ADD(&e->l_entry, &prof->entries);
2896         } else {
2897                 if (do_chg_action) {
2898                         /* For the action memory info, update the SW's copy of
2899                          * exist entry with e's action memory info
2900                          */
2901                         ice_free(hw, exist->acts);
2902                         exist->acts_cnt = e->acts_cnt;
2903                         exist->acts = (struct ice_flow_action *)
2904                                 ice_calloc(hw, exist->acts_cnt,
2905                                            sizeof(struct ice_flow_action));
2906
2907                         if (!exist->acts) {
2908                                 status = ICE_ERR_NO_MEMORY;
2909                                 goto out;
2910                         }
2911
2912                         ice_memcpy(exist->acts, e->acts,
2913                                    sizeof(struct ice_flow_action) * e->acts_cnt,
2914                                    ICE_NONDMA_TO_NONDMA);
2915
2916                         status = ice_acl_prog_act(hw, prof->cfg.scen, acts,
2917                                                   e->acts_cnt,
2918                                                   exist->scen_entry_idx);
2919                         if (status)
2920                                 goto out;
2921                 }
2922
2923                 if (do_chg_rng_chk) {
2924                         /* In this case, we want to update the range checker
2925                          * information of the exist entry
2926                          */
2927                         status = ice_flow_acl_union_rng_chk(exist->range_buf,
2928                                                             e->range_buf);
2929                         if (status)
2930                                 goto out;
2931                 }
2932
2933                 /* As we don't add the new entry to our SW DB, deallocate its
2934                  * memories, and return the exist entry to the caller
2935                  */
2936                 ice_dealloc_flow_entry(hw, e);
2937                 *(entry) = exist;
2938         }
2939 out:
2940         if (acts)
2941                 ice_free(hw, acts);
2942
2943         return status;
2944 }
2945
2946 /**
2947  * ice_flow_acl_add_scen_entry - Add entry to ACL scenario
2948  * @hw: pointer to the hardware structure
2949  * @prof: pointer to flow profile
2950  * @e: double pointer to the flow entry
2951  */
2952 static enum ice_status
2953 ice_flow_acl_add_scen_entry(struct ice_hw *hw, struct ice_flow_prof *prof,
2954                             struct ice_flow_entry **e)
2955 {
2956         enum ice_status status;
2957
2958         ice_acquire_lock(&prof->entries_lock);
2959         status = ice_flow_acl_add_scen_entry_sync(hw, prof, e);
2960         ice_release_lock(&prof->entries_lock);
2961
2962         return status;
2963 }
2964
2965 /**
2966  * ice_flow_add_entry - Add a flow entry
2967  * @hw: pointer to the HW struct
2968  * @blk: classification stage
2969  * @prof_id: ID of the profile to add a new flow entry to
2970  * @entry_id: unique ID to identify this flow entry
2971  * @vsi_handle: software VSI handle for the flow entry
2972  * @prio: priority of the flow entry
2973  * @data: pointer to a data buffer containing flow entry's match values/masks
2974  * @acts: arrays of actions to be performed on a match
2975  * @acts_cnt: number of actions
2976  * @entry_h: pointer to buffer that receives the new flow entry's handle
2977  */
2978 enum ice_status
2979 ice_flow_add_entry(struct ice_hw *hw, enum ice_block blk, u64 prof_id,
2980                    u64 entry_id, u16 vsi_handle, enum ice_flow_priority prio,
2981                    void *data, struct ice_flow_action *acts, u8 acts_cnt,
2982                    u64 *entry_h)
2983 {
2984         struct ice_flow_entry *e = NULL;
2985         struct ice_flow_prof *prof;
2986         enum ice_status status = ICE_SUCCESS;
2987
2988         /* ACL entries must indicate an action */
2989         if (blk == ICE_BLK_ACL && (!acts || !acts_cnt))
2990                 return ICE_ERR_PARAM;
2991
2992         /* No flow entry data is expected for RSS */
2993         if (!entry_h || (!data && blk != ICE_BLK_RSS))
2994                 return ICE_ERR_BAD_PTR;
2995
2996         if (!ice_is_vsi_valid(hw, vsi_handle))
2997                 return ICE_ERR_PARAM;
2998
2999         ice_acquire_lock(&hw->fl_profs_locks[blk]);
3000
3001         prof = ice_flow_find_prof_id(hw, blk, prof_id);
3002         if (!prof) {
3003                 status = ICE_ERR_DOES_NOT_EXIST;
3004         } else {
3005                 /* Allocate memory for the entry being added and associate
3006                  * the VSI to the found flow profile
3007                  */
3008                 e = (struct ice_flow_entry *)ice_malloc(hw, sizeof(*e));
3009                 if (!e)
3010                         status = ICE_ERR_NO_MEMORY;
3011                 else
3012                         status = ice_flow_assoc_prof(hw, blk, prof, vsi_handle);
3013         }
3014
3015         ice_release_lock(&hw->fl_profs_locks[blk]);
3016         if (status)
3017                 goto out;
3018
3019         e->id = entry_id;
3020         e->vsi_handle = vsi_handle;
3021         e->prof = prof;
3022         e->priority = prio;
3023
3024         switch (blk) {
3025         case ICE_BLK_FD:
3026         case ICE_BLK_RSS:
3027                 break;
3028         case ICE_BLK_ACL:
3029                 /* ACL will handle the entry management */
3030                 status = ice_flow_acl_frmt_entry(hw, prof, e, (u8 *)data, acts,
3031                                                  acts_cnt);
3032                 if (status)
3033                         goto out;
3034
3035                 status = ice_flow_acl_add_scen_entry(hw, prof, &e);
3036                 if (status)
3037                         goto out;
3038
3039                 break;
3040         default:
3041                 status = ICE_ERR_NOT_IMPL;
3042                 goto out;
3043         }
3044
3045         if (blk != ICE_BLK_ACL) {
3046                 /* ACL will handle the entry management */
3047                 ice_acquire_lock(&prof->entries_lock);
3048                 LIST_ADD(&e->l_entry, &prof->entries);
3049                 ice_release_lock(&prof->entries_lock);
3050         }
3051
3052         *entry_h = ICE_FLOW_ENTRY_HNDL(e);
3053
3054 out:
3055         if (status && e) {
3056                 if (e->entry)
3057                         ice_free(hw, e->entry);
3058                 ice_free(hw, e);
3059         }
3060
3061         return status;
3062 }
3063
3064 /**
3065  * ice_flow_rem_entry - Remove a flow entry
3066  * @hw: pointer to the HW struct
3067  * @blk: classification stage
3068  * @entry_h: handle to the flow entry to be removed
3069  */
3070 enum ice_status ice_flow_rem_entry(struct ice_hw *hw, enum ice_block blk,
3071                                    u64 entry_h)
3072 {
3073         struct ice_flow_entry *entry;
3074         struct ice_flow_prof *prof;
3075         enum ice_status status = ICE_SUCCESS;
3076
3077         if (entry_h == ICE_FLOW_ENTRY_HANDLE_INVAL)
3078                 return ICE_ERR_PARAM;
3079
3080         entry = ICE_FLOW_ENTRY_PTR((unsigned long)entry_h);
3081
3082         /* Retain the pointer to the flow profile as the entry will be freed */
3083         prof = entry->prof;
3084
3085         if (prof) {
3086                 ice_acquire_lock(&prof->entries_lock);
3087                 status = ice_flow_rem_entry_sync(hw, blk, entry);
3088                 ice_release_lock(&prof->entries_lock);
3089         }
3090
3091         return status;
3092 }
3093
3094 /**
3095  * ice_flow_set_fld_ext - specifies locations of field from entry's input buffer
3096  * @seg: packet segment the field being set belongs to
3097  * @fld: field to be set
3098  * @field_type: type of the field
3099  * @val_loc: if not ICE_FLOW_FLD_OFF_INVAL, location of the value to match from
3100  *           entry's input buffer
3101  * @mask_loc: if not ICE_FLOW_FLD_OFF_INVAL, location of mask value from entry's
3102  *            input buffer
3103  * @last_loc: if not ICE_FLOW_FLD_OFF_INVAL, location of last/upper value from
3104  *            entry's input buffer
3105  *
3106  * This helper function stores information of a field being matched, including
3107  * the type of the field and the locations of the value to match, the mask, and
3108  * and the upper-bound value in the start of the input buffer for a flow entry.
3109  * This function should only be used for fixed-size data structures.
3110  *
3111  * This function also opportunistically determines the protocol headers to be
3112  * present based on the fields being set. Some fields cannot be used alone to
3113  * determine the protocol headers present. Sometimes, fields for particular
3114  * protocol headers are not matched. In those cases, the protocol headers
3115  * must be explicitly set.
3116  */
3117 static void
3118 ice_flow_set_fld_ext(struct ice_flow_seg_info *seg, enum ice_flow_field fld,
3119                      enum ice_flow_fld_match_type field_type, u16 val_loc,
3120                      u16 mask_loc, u16 last_loc)
3121 {
3122         u64 bit = BIT_ULL(fld);
3123
3124         seg->match |= bit;
3125         if (field_type == ICE_FLOW_FLD_TYPE_RANGE)
3126                 seg->range |= bit;
3127
3128         seg->fields[fld].type = field_type;
3129         seg->fields[fld].src.val = val_loc;
3130         seg->fields[fld].src.mask = mask_loc;
3131         seg->fields[fld].src.last = last_loc;
3132
3133         ICE_FLOW_SET_HDRS(seg, ice_flds_info[fld].hdr);
3134 }
3135
3136 /**
3137  * ice_flow_set_fld - specifies locations of field from entry's input buffer
3138  * @seg: packet segment the field being set belongs to
3139  * @fld: field to be set
3140  * @val_loc: if not ICE_FLOW_FLD_OFF_INVAL, location of the value to match from
3141  *           entry's input buffer
3142  * @mask_loc: if not ICE_FLOW_FLD_OFF_INVAL, location of mask value from entry's
3143  *            input buffer
3144  * @last_loc: if not ICE_FLOW_FLD_OFF_INVAL, location of last/upper value from
3145  *            entry's input buffer
3146  * @range: indicate if field being matched is to be in a range
3147  *
3148  * This function specifies the locations, in the form of byte offsets from the
3149  * start of the input buffer for a flow entry, from where the value to match,
3150  * the mask value, and upper value can be extracted. These locations are then
3151  * stored in the flow profile. When adding a flow entry associated with the
3152  * flow profile, these locations will be used to quickly extract the values and
3153  * create the content of a match entry. This function should only be used for
3154  * fixed-size data structures.
3155  */
3156 void
3157 ice_flow_set_fld(struct ice_flow_seg_info *seg, enum ice_flow_field fld,
3158                  u16 val_loc, u16 mask_loc, u16 last_loc, bool range)
3159 {
3160         enum ice_flow_fld_match_type t = range ?
3161                 ICE_FLOW_FLD_TYPE_RANGE : ICE_FLOW_FLD_TYPE_REG;
3162
3163         ice_flow_set_fld_ext(seg, fld, t, val_loc, mask_loc, last_loc);
3164 }
3165
3166 /**
3167  * ice_flow_set_fld_prefix - sets locations of prefix field from entry's buf
3168  * @seg: packet segment the field being set belongs to
3169  * @fld: field to be set
3170  * @val_loc: if not ICE_FLOW_FLD_OFF_INVAL, location of the value to match from
3171  *           entry's input buffer
3172  * @pref_loc: location of prefix value from entry's input buffer
3173  * @pref_sz: size of the location holding the prefix value
3174  *
3175  * This function specifies the locations, in the form of byte offsets from the
3176  * start of the input buffer for a flow entry, from where the value to match
3177  * and the IPv4 prefix value can be extracted. These locations are then stored
3178  * in the flow profile. When adding flow entries to the associated flow profile,
3179  * these locations can be used to quickly extract the values to create the
3180  * content of a match entry. This function should only be used for fixed-size
3181  * data structures.
3182  */
3183 void
3184 ice_flow_set_fld_prefix(struct ice_flow_seg_info *seg, enum ice_flow_field fld,
3185                         u16 val_loc, u16 pref_loc, u8 pref_sz)
3186 {
3187         /* For this type of field, the "mask" location is for the prefix value's
3188          * location and the "last" location is for the size of the location of
3189          * the prefix value.
3190          */
3191         ice_flow_set_fld_ext(seg, fld, ICE_FLOW_FLD_TYPE_PREFIX, val_loc,
3192                              pref_loc, (u16)pref_sz);
3193 }
3194
3195 /**
3196  * ice_flow_add_fld_raw - sets locations of a raw field from entry's input buf
3197  * @seg: packet segment the field being set belongs to
3198  * @off: offset of the raw field from the beginning of the segment in bytes
3199  * @len: length of the raw pattern to be matched
3200  * @val_loc: location of the value to match from entry's input buffer
3201  * @mask_loc: location of mask value from entry's input buffer
3202  *
3203  * This function specifies the offset of the raw field to be match from the
3204  * beginning of the specified packet segment, and the locations, in the form of
3205  * byte offsets from the start of the input buffer for a flow entry, from where
3206  * the value to match and the mask value to be extracted. These locations are
3207  * then stored in the flow profile. When adding flow entries to the associated
3208  * flow profile, these locations can be used to quickly extract the values to
3209  * create the content of a match entry. This function should only be used for
3210  * fixed-size data structures.
3211  */
3212 void
3213 ice_flow_add_fld_raw(struct ice_flow_seg_info *seg, u16 off, u8 len,
3214                      u16 val_loc, u16 mask_loc)
3215 {
3216         if (seg->raws_cnt < ICE_FLOW_SEG_RAW_FLD_MAX) {
3217                 seg->raws[seg->raws_cnt].off = off;
3218                 seg->raws[seg->raws_cnt].info.type = ICE_FLOW_FLD_TYPE_SIZE;
3219                 seg->raws[seg->raws_cnt].info.src.val = val_loc;
3220                 seg->raws[seg->raws_cnt].info.src.mask = mask_loc;
3221                 /* The "last" field is used to store the length of the field */
3222                 seg->raws[seg->raws_cnt].info.src.last = len;
3223         }
3224
3225         /* Overflows of "raws" will be handled as an error condition later in
3226          * the flow when this information is processed.
3227          */
3228         seg->raws_cnt++;
3229 }
3230
3231 #define ICE_FLOW_RSS_SEG_HDR_L2_MASKS \
3232 (ICE_FLOW_SEG_HDR_ETH | ICE_FLOW_SEG_HDR_VLAN)
3233
3234 #define ICE_FLOW_RSS_SEG_HDR_L3_MASKS \
3235         (ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV6)
3236
3237 #define ICE_FLOW_RSS_SEG_HDR_L4_MASKS \
3238         (ICE_FLOW_SEG_HDR_TCP | ICE_FLOW_SEG_HDR_UDP | \
3239          ICE_FLOW_SEG_HDR_SCTP)
3240
3241 #define ICE_FLOW_RSS_SEG_HDR_VAL_MASKS \
3242         (ICE_FLOW_RSS_SEG_HDR_L2_MASKS | \
3243          ICE_FLOW_RSS_SEG_HDR_L3_MASKS | \
3244          ICE_FLOW_RSS_SEG_HDR_L4_MASKS)
3245
3246 /**
3247  * ice_flow_set_rss_seg_info - setup packet segments for RSS
3248  * @segs: pointer to the flow field segment(s)
3249  * @hash_fields: fields to be hashed on for the segment(s)
3250  * @flow_hdr: protocol header fields within a packet segment
3251  *
3252  * Helper function to extract fields from hash bitmap and use flow
3253  * header value to set flow field segment for further use in flow
3254  * profile entry or removal.
3255  */
3256 static enum ice_status
3257 ice_flow_set_rss_seg_info(struct ice_flow_seg_info *segs, u64 hash_fields,
3258                           u32 flow_hdr)
3259 {
3260         u64 val;
3261         u8 i;
3262
3263         ice_for_each_set_bit(i, (ice_bitmap_t *)&hash_fields,
3264                              ICE_FLOW_FIELD_IDX_MAX)
3265                 ice_flow_set_fld(segs, (enum ice_flow_field)i,
3266                                  ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
3267                                  ICE_FLOW_FLD_OFF_INVAL, false);
3268
3269         ICE_FLOW_SET_HDRS(segs, flow_hdr);
3270
3271         if (segs->hdrs & ~ICE_FLOW_RSS_SEG_HDR_VAL_MASKS &
3272             ~ICE_FLOW_RSS_HDRS_INNER_MASK & ~ICE_FLOW_SEG_HDR_IPV_OTHER)
3273                 return ICE_ERR_PARAM;
3274
3275         val = (u64)(segs->hdrs & ICE_FLOW_RSS_SEG_HDR_L3_MASKS);
3276         if (val && !ice_is_pow2(val))
3277                 return ICE_ERR_CFG;
3278
3279         val = (u64)(segs->hdrs & ICE_FLOW_RSS_SEG_HDR_L4_MASKS);
3280         if (val && !ice_is_pow2(val))
3281                 return ICE_ERR_CFG;
3282
3283         return ICE_SUCCESS;
3284 }
3285
3286 /**
3287  * ice_rem_vsi_rss_list - remove VSI from RSS list
3288  * @hw: pointer to the hardware structure
3289  * @vsi_handle: software VSI handle
3290  *
3291  * Remove the VSI from all RSS configurations in the list.
3292  */
3293 void ice_rem_vsi_rss_list(struct ice_hw *hw, u16 vsi_handle)
3294 {
3295         struct ice_rss_cfg *r, *tmp;
3296
3297         if (LIST_EMPTY(&hw->rss_list_head))
3298                 return;
3299
3300         ice_acquire_lock(&hw->rss_locks);
3301         LIST_FOR_EACH_ENTRY_SAFE(r, tmp, &hw->rss_list_head,
3302                                  ice_rss_cfg, l_entry)
3303                 if (ice_test_and_clear_bit(vsi_handle, r->vsis))
3304                         if (!ice_is_any_bit_set(r->vsis, ICE_MAX_VSI)) {
3305                                 LIST_DEL(&r->l_entry);
3306                                 ice_free(hw, r);
3307                         }
3308         ice_release_lock(&hw->rss_locks);
3309 }
3310
3311 /**
3312  * ice_rem_vsi_rss_cfg - remove RSS configurations associated with VSI
3313  * @hw: pointer to the hardware structure
3314  * @vsi_handle: software VSI handle
3315  *
3316  * This function will iterate through all flow profiles and disassociate
3317  * the VSI from that profile. If the flow profile has no VSIs it will
3318  * be removed.
3319  */
3320 enum ice_status ice_rem_vsi_rss_cfg(struct ice_hw *hw, u16 vsi_handle)
3321 {
3322         const enum ice_block blk = ICE_BLK_RSS;
3323         struct ice_flow_prof *p, *t;
3324         enum ice_status status = ICE_SUCCESS;
3325
3326         if (!ice_is_vsi_valid(hw, vsi_handle))
3327                 return ICE_ERR_PARAM;
3328
3329         if (LIST_EMPTY(&hw->fl_profs[blk]))
3330                 return ICE_SUCCESS;
3331
3332         ice_acquire_lock(&hw->rss_locks);
3333         LIST_FOR_EACH_ENTRY_SAFE(p, t, &hw->fl_profs[blk], ice_flow_prof,
3334                                  l_entry)
3335                 if (ice_is_bit_set(p->vsis, vsi_handle)) {
3336                         status = ice_flow_disassoc_prof(hw, blk, p, vsi_handle);
3337                         if (status)
3338                                 break;
3339
3340                         if (!ice_is_any_bit_set(p->vsis, ICE_MAX_VSI)) {
3341                                 status = ice_flow_rem_prof(hw, blk, p->id);
3342                                 if (status)
3343                                         break;
3344                         }
3345                 }
3346         ice_release_lock(&hw->rss_locks);
3347
3348         return status;
3349 }
3350
3351 /**
3352  * ice_rem_rss_list - remove RSS configuration from list
3353  * @hw: pointer to the hardware structure
3354  * @vsi_handle: software VSI handle
3355  * @prof: pointer to flow profile
3356  *
3357  * Assumption: lock has already been acquired for RSS list
3358  */
3359 static void
3360 ice_rem_rss_list(struct ice_hw *hw, u16 vsi_handle, struct ice_flow_prof *prof)
3361 {
3362         struct ice_rss_cfg *r, *tmp;
3363
3364         /* Search for RSS hash fields associated to the VSI that match the
3365          * hash configurations associated to the flow profile. If found
3366          * remove from the RSS entry list of the VSI context and delete entry.
3367          */
3368         LIST_FOR_EACH_ENTRY_SAFE(r, tmp, &hw->rss_list_head,
3369                                  ice_rss_cfg, l_entry)
3370                 if (r->hashed_flds == prof->segs[prof->segs_cnt - 1].match &&
3371                     r->packet_hdr == prof->segs[prof->segs_cnt - 1].hdrs) {
3372                         ice_clear_bit(vsi_handle, r->vsis);
3373                         if (!ice_is_any_bit_set(r->vsis, ICE_MAX_VSI)) {
3374                                 LIST_DEL(&r->l_entry);
3375                                 ice_free(hw, r);
3376                         }
3377                         return;
3378                 }
3379 }
3380
3381 /**
3382  * ice_add_rss_list - add RSS configuration to list
3383  * @hw: pointer to the hardware structure
3384  * @vsi_handle: software VSI handle
3385  * @prof: pointer to flow profile
3386  *
3387  * Assumption: lock has already been acquired for RSS list
3388  */
3389 static enum ice_status
3390 ice_add_rss_list(struct ice_hw *hw, u16 vsi_handle, struct ice_flow_prof *prof)
3391 {
3392         struct ice_rss_cfg *r, *rss_cfg;
3393
3394         LIST_FOR_EACH_ENTRY(r, &hw->rss_list_head,
3395                             ice_rss_cfg, l_entry)
3396                 if (r->hashed_flds == prof->segs[prof->segs_cnt - 1].match &&
3397                     r->packet_hdr == prof->segs[prof->segs_cnt - 1].hdrs) {
3398                         ice_set_bit(vsi_handle, r->vsis);
3399                         return ICE_SUCCESS;
3400                 }
3401
3402         rss_cfg = (struct ice_rss_cfg *)ice_malloc(hw, sizeof(*rss_cfg));
3403         if (!rss_cfg)
3404                 return ICE_ERR_NO_MEMORY;
3405
3406         rss_cfg->hashed_flds = prof->segs[prof->segs_cnt - 1].match;
3407         rss_cfg->packet_hdr = prof->segs[prof->segs_cnt - 1].hdrs;
3408         rss_cfg->symm = prof->cfg.symm;
3409         ice_set_bit(vsi_handle, rss_cfg->vsis);
3410
3411         LIST_ADD_TAIL(&rss_cfg->l_entry, &hw->rss_list_head);
3412
3413         return ICE_SUCCESS;
3414 }
3415
3416 #define ICE_FLOW_PROF_HASH_S    0
3417 #define ICE_FLOW_PROF_HASH_M    (0xFFFFFFFFULL << ICE_FLOW_PROF_HASH_S)
3418 #define ICE_FLOW_PROF_HDR_S     32
3419 #define ICE_FLOW_PROF_HDR_M     (0x3FFFFFFFULL << ICE_FLOW_PROF_HDR_S)
3420 #define ICE_FLOW_PROF_ENCAP_S   63
3421 #define ICE_FLOW_PROF_ENCAP_M   (BIT_ULL(ICE_FLOW_PROF_ENCAP_S))
3422
3423 #define ICE_RSS_OUTER_HEADERS   1
3424 #define ICE_RSS_INNER_HEADERS   2
3425
3426 /* Flow profile ID format:
3427  * [0:31] - Packet match fields
3428  * [32:62] - Protocol header
3429  * [63] - Encapsulation flag, 0 if non-tunneled, 1 if tunneled
3430  */
3431 #define ICE_FLOW_GEN_PROFID(hash, hdr, segs_cnt) \
3432         (u64)(((u64)(hash) & ICE_FLOW_PROF_HASH_M) | \
3433               (((u64)(hdr) << ICE_FLOW_PROF_HDR_S) & ICE_FLOW_PROF_HDR_M) | \
3434               ((u8)((segs_cnt) - 1) ? ICE_FLOW_PROF_ENCAP_M : 0))
3435
3436 static void
3437 ice_rss_config_xor_word(struct ice_hw *hw, u8 prof_id, u8 src, u8 dst)
3438 {
3439         u32 s = ((src % 4) << 3); /* byte shift */
3440         u32 v = dst | 0x80; /* value to program */
3441         u8 i = src / 4; /* register index */
3442         u32 reg;
3443
3444         reg = rd32(hw, GLQF_HSYMM(prof_id, i));
3445         reg = (reg & ~(0xff << s)) | (v << s);
3446         wr32(hw, GLQF_HSYMM(prof_id, i), reg);
3447 }
3448
3449 static void
3450 ice_rss_config_xor(struct ice_hw *hw, u8 prof_id, u8 src, u8 dst, u8 len)
3451 {
3452         int fv_last_word =
3453                 ICE_FLOW_SW_FIELD_VECTOR_MAX / ICE_FLOW_FV_EXTRACT_SZ - 1;
3454         int i;
3455
3456         for (i = 0; i < len; i++) {
3457                 ice_rss_config_xor_word(hw, prof_id,
3458                                         /* Yes, field vector in GLQF_HSYMM and
3459                                          * GLQF_HINSET is inversed!
3460                                          */
3461                                         fv_last_word - (src + i),
3462                                         fv_last_word - (dst + i));
3463                 ice_rss_config_xor_word(hw, prof_id,
3464                                         fv_last_word - (dst + i),
3465                                         fv_last_word - (src + i));
3466         }
3467 }
3468
3469 static void
3470 ice_rss_update_symm(struct ice_hw *hw,
3471                     struct ice_flow_prof *prof)
3472 {
3473         struct ice_prof_map *map;
3474         u8 prof_id, m;
3475
3476         ice_acquire_lock(&hw->blk[ICE_BLK_RSS].es.prof_map_lock);
3477         map = ice_search_prof_id(hw, ICE_BLK_RSS, prof->id);
3478         if (map)
3479                 prof_id = map->prof_id;
3480         ice_release_lock(&hw->blk[ICE_BLK_RSS].es.prof_map_lock);
3481         if (!map)
3482                 return;
3483         /* clear to default */
3484         for (m = 0; m < 6; m++)
3485                 wr32(hw, GLQF_HSYMM(prof_id, m), 0);
3486         if (prof->cfg.symm) {
3487                 struct ice_flow_seg_info *seg =
3488                         &prof->segs[prof->segs_cnt - 1];
3489
3490                 struct ice_flow_seg_xtrct *ipv4_src =
3491                         &seg->fields[ICE_FLOW_FIELD_IDX_IPV4_SA].xtrct;
3492                 struct ice_flow_seg_xtrct *ipv4_dst =
3493                         &seg->fields[ICE_FLOW_FIELD_IDX_IPV4_DA].xtrct;
3494                 struct ice_flow_seg_xtrct *ipv6_src =
3495                         &seg->fields[ICE_FLOW_FIELD_IDX_IPV6_SA].xtrct;
3496                 struct ice_flow_seg_xtrct *ipv6_dst =
3497                         &seg->fields[ICE_FLOW_FIELD_IDX_IPV6_DA].xtrct;
3498
3499                 struct ice_flow_seg_xtrct *tcp_src =
3500                         &seg->fields[ICE_FLOW_FIELD_IDX_TCP_SRC_PORT].xtrct;
3501                 struct ice_flow_seg_xtrct *tcp_dst =
3502                         &seg->fields[ICE_FLOW_FIELD_IDX_TCP_DST_PORT].xtrct;
3503
3504                 struct ice_flow_seg_xtrct *udp_src =
3505                         &seg->fields[ICE_FLOW_FIELD_IDX_UDP_SRC_PORT].xtrct;
3506                 struct ice_flow_seg_xtrct *udp_dst =
3507                         &seg->fields[ICE_FLOW_FIELD_IDX_UDP_DST_PORT].xtrct;
3508
3509                 struct ice_flow_seg_xtrct *sctp_src =
3510                         &seg->fields[ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT].xtrct;
3511                 struct ice_flow_seg_xtrct *sctp_dst =
3512                         &seg->fields[ICE_FLOW_FIELD_IDX_SCTP_DST_PORT].xtrct;
3513
3514                 /* xor IPv4 */
3515                 if (ipv4_src->prot_id != 0 && ipv4_dst->prot_id != 0)
3516                         ice_rss_config_xor(hw, prof_id,
3517                                            ipv4_src->idx, ipv4_dst->idx, 2);
3518
3519                 /* xor IPv6 */
3520                 if (ipv6_src->prot_id != 0 && ipv6_dst->prot_id != 0)
3521                         ice_rss_config_xor(hw, prof_id,
3522                                            ipv6_src->idx, ipv6_dst->idx, 8);
3523
3524                 /* xor TCP */
3525                 if (tcp_src->prot_id != 0 && tcp_dst->prot_id != 0)
3526                         ice_rss_config_xor(hw, prof_id,
3527                                            tcp_src->idx, tcp_dst->idx, 1);
3528
3529                 /* xor UDP */
3530                 if (udp_src->prot_id != 0 && udp_dst->prot_id != 0)
3531                         ice_rss_config_xor(hw, prof_id,
3532                                            udp_src->idx, udp_dst->idx, 1);
3533
3534                 /* xor SCTP */
3535                 if (sctp_src->prot_id != 0 && sctp_dst->prot_id != 0)
3536                         ice_rss_config_xor(hw, prof_id,
3537                                            sctp_src->idx, sctp_dst->idx, 1);
3538         }
3539 }
3540
3541 /**
3542  * ice_add_rss_cfg_sync - add an RSS configuration
3543  * @hw: pointer to the hardware structure
3544  * @vsi_handle: software VSI handle
3545  * @hashed_flds: hash bit fields (ICE_FLOW_HASH_*) to configure
3546  * @addl_hdrs: protocol header fields
3547  * @segs_cnt: packet segment count
3548  * @symm: symmetric hash enable/disable
3549  *
3550  * Assumption: lock has already been acquired for RSS list
3551  */
3552 static enum ice_status
3553 ice_add_rss_cfg_sync(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds,
3554                      u32 addl_hdrs, u8 segs_cnt, bool symm)
3555 {
3556         const enum ice_block blk = ICE_BLK_RSS;
3557         struct ice_flow_prof *prof = NULL;
3558         struct ice_flow_seg_info *segs;
3559         enum ice_status status;
3560
3561         if (!segs_cnt || segs_cnt > ICE_FLOW_SEG_MAX)
3562                 return ICE_ERR_PARAM;
3563
3564         segs = (struct ice_flow_seg_info *)ice_calloc(hw, segs_cnt,
3565                                                       sizeof(*segs));
3566         if (!segs)
3567                 return ICE_ERR_NO_MEMORY;
3568
3569         /* Construct the packet segment info from the hashed fields */
3570         status = ice_flow_set_rss_seg_info(&segs[segs_cnt - 1], hashed_flds,
3571                                            addl_hdrs);
3572         if (status)
3573                 goto exit;
3574
3575         /* don't do RSS for GTPU outer */
3576         if (segs_cnt == ICE_RSS_OUTER_HEADERS &&
3577             segs[segs_cnt - 1].hdrs & ICE_FLOW_SEG_HDR_GTPU) {
3578                 status = ICE_SUCCESS;
3579                 goto exit;
3580         }
3581
3582         /* Search for a flow profile that has matching headers, hash fields
3583          * and has the input VSI associated to it. If found, no further
3584          * operations required and exit.
3585          */
3586         prof = ice_flow_find_prof_conds(hw, blk, ICE_FLOW_RX, segs, segs_cnt,
3587                                         vsi_handle,
3588                                         ICE_FLOW_FIND_PROF_CHK_FLDS |
3589                                         ICE_FLOW_FIND_PROF_CHK_VSI);
3590         if (prof) {
3591                 if (prof->cfg.symm == symm)
3592                         goto exit;
3593                 prof->cfg.symm = symm;
3594                 goto update_symm;
3595         }
3596
3597         /* Check if a flow profile exists with the same protocol headers and
3598          * associated with the input VSI. If so disassociate the VSI from
3599          * this profile. The VSI will be added to a new profile created with
3600          * the protocol header and new hash field configuration.
3601          */
3602         prof = ice_flow_find_prof_conds(hw, blk, ICE_FLOW_RX, segs, segs_cnt,
3603                                         vsi_handle, ICE_FLOW_FIND_PROF_CHK_VSI);
3604         if (prof) {
3605                 status = ice_flow_disassoc_prof(hw, blk, prof, vsi_handle);
3606                 if (!status)
3607                         ice_rem_rss_list(hw, vsi_handle, prof);
3608                 else
3609                         goto exit;
3610
3611                 /* Remove profile if it has no VSIs associated */
3612                 if (!ice_is_any_bit_set(prof->vsis, ICE_MAX_VSI)) {
3613                         status = ice_flow_rem_prof(hw, blk, prof->id);
3614                         if (status)
3615                                 goto exit;
3616                 }
3617         }
3618
3619         /* Search for a profile that has same match fields only. If this
3620          * exists then associate the VSI to this profile.
3621          */
3622         prof = ice_flow_find_prof_conds(hw, blk, ICE_FLOW_RX, segs, segs_cnt,
3623                                         vsi_handle,
3624                                         ICE_FLOW_FIND_PROF_CHK_FLDS);
3625         if (prof) {
3626                 if (prof->cfg.symm == symm) {
3627                         status = ice_flow_assoc_prof(hw, blk, prof,
3628                                                      vsi_handle);
3629                         if (!status)
3630                                 status = ice_add_rss_list(hw, vsi_handle,
3631                                                           prof);
3632                 } else {
3633                         /* if a profile exist but with different symmetric
3634                          * requirement, just return error.
3635                          */
3636                         status = ICE_ERR_NOT_SUPPORTED;
3637                 }
3638                 goto exit;
3639         }
3640
3641         /* Create a new flow profile with generated profile and packet
3642          * segment information.
3643          */
3644         status = ice_flow_add_prof(hw, blk, ICE_FLOW_RX,
3645                                    ICE_FLOW_GEN_PROFID(hashed_flds,
3646                                                        segs[segs_cnt - 1].hdrs,
3647                                                        segs_cnt),
3648                                    segs, segs_cnt, NULL, 0, &prof);
3649         if (status)
3650                 goto exit;
3651
3652         status = ice_flow_assoc_prof(hw, blk, prof, vsi_handle);
3653         /* If association to a new flow profile failed then this profile can
3654          * be removed.
3655          */
3656         if (status) {
3657                 ice_flow_rem_prof(hw, blk, prof->id);
3658                 goto exit;
3659         }
3660
3661         status = ice_add_rss_list(hw, vsi_handle, prof);
3662
3663         prof->cfg.symm = symm;
3664
3665 update_symm:
3666         ice_rss_update_symm(hw, prof);
3667
3668 exit:
3669         ice_free(hw, segs);
3670         return status;
3671 }
3672
3673 /**
3674  * ice_add_rss_cfg - add an RSS configuration with specified hashed fields
3675  * @hw: pointer to the hardware structure
3676  * @vsi_handle: software VSI handle
3677  * @hashed_flds: hash bit fields (ICE_FLOW_HASH_*) to configure
3678  * @addl_hdrs: protocol header fields
3679  * @symm: symmetric hash enable/disable
3680  *
3681  * This function will generate a flow profile based on fields associated with
3682  * the input fields to hash on, the flow type and use the VSI number to add
3683  * a flow entry to the profile.
3684  */
3685 enum ice_status
3686 ice_add_rss_cfg(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds,
3687                 u32 addl_hdrs, bool symm)
3688 {
3689         enum ice_status status;
3690
3691         if (hashed_flds == ICE_HASH_INVALID ||
3692             !ice_is_vsi_valid(hw, vsi_handle))
3693                 return ICE_ERR_PARAM;
3694
3695         ice_acquire_lock(&hw->rss_locks);
3696         status = ice_add_rss_cfg_sync(hw, vsi_handle, hashed_flds, addl_hdrs,
3697                                       ICE_RSS_OUTER_HEADERS, symm);
3698
3699         if (!status)
3700                 status = ice_add_rss_cfg_sync(hw, vsi_handle, hashed_flds,
3701                                               addl_hdrs, ICE_RSS_INNER_HEADERS,
3702                                               symm);
3703         ice_release_lock(&hw->rss_locks);
3704
3705         return status;
3706 }
3707
3708 /**
3709  * ice_rem_rss_cfg_sync - remove an existing RSS configuration
3710  * @hw: pointer to the hardware structure
3711  * @vsi_handle: software VSI handle
3712  * @hashed_flds: Packet hash types (ICE_FLOW_HASH_*) to remove
3713  * @addl_hdrs: Protocol header fields within a packet segment
3714  * @segs_cnt: packet segment count
3715  *
3716  * Assumption: lock has already been acquired for RSS list
3717  */
3718 static enum ice_status
3719 ice_rem_rss_cfg_sync(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds,
3720                      u32 addl_hdrs, u8 segs_cnt)
3721 {
3722         const enum ice_block blk = ICE_BLK_RSS;
3723         struct ice_flow_seg_info *segs;
3724         struct ice_flow_prof *prof;
3725         enum ice_status status;
3726
3727         segs = (struct ice_flow_seg_info *)ice_calloc(hw, segs_cnt,
3728                                                       sizeof(*segs));
3729         if (!segs)
3730                 return ICE_ERR_NO_MEMORY;
3731
3732         /* Construct the packet segment info from the hashed fields */
3733         status = ice_flow_set_rss_seg_info(&segs[segs_cnt - 1], hashed_flds,
3734                                            addl_hdrs);
3735         if (status)
3736                 goto out;
3737
3738         if (segs_cnt == ICE_RSS_OUTER_HEADERS &&
3739             segs[segs_cnt - 1].hdrs & ICE_FLOW_SEG_HDR_GTPU) {
3740                 status = ICE_SUCCESS;
3741                 goto out;
3742         }
3743
3744         prof = ice_flow_find_prof_conds(hw, blk, ICE_FLOW_RX, segs, segs_cnt,
3745                                         vsi_handle,
3746                                         ICE_FLOW_FIND_PROF_CHK_FLDS);
3747         if (!prof) {
3748                 status = ICE_ERR_DOES_NOT_EXIST;
3749                 goto out;
3750         }
3751
3752         status = ice_flow_disassoc_prof(hw, blk, prof, vsi_handle);
3753         if (status)
3754                 goto out;
3755
3756         /* Remove RSS configuration from VSI context before deleting
3757          * the flow profile.
3758          */
3759         ice_rem_rss_list(hw, vsi_handle, prof);
3760
3761         if (!ice_is_any_bit_set(prof->vsis, ICE_MAX_VSI))
3762                 status = ice_flow_rem_prof(hw, blk, prof->id);
3763
3764 out:
3765         ice_free(hw, segs);
3766         return status;
3767 }
3768
3769 /**
3770  * ice_rem_rss_cfg - remove an existing RSS config with matching hashed fields
3771  * @hw: pointer to the hardware structure
3772  * @vsi_handle: software VSI handle
3773  * @hashed_flds: Packet hash types (ICE_FLOW_HASH_*) to remove
3774  * @addl_hdrs: Protocol header fields within a packet segment
3775  *
3776  * This function will lookup the flow profile based on the input
3777  * hash field bitmap, iterate through the profile entry list of
3778  * that profile and find entry associated with input VSI to be
3779  * removed. Calls are made to underlying flow apis which will in
3780  * turn build or update buffers for RSS XLT1 section.
3781  */
3782 enum ice_status
3783 ice_rem_rss_cfg(struct ice_hw *hw, u16 vsi_handle, u64 hashed_flds,
3784                 u32 addl_hdrs)
3785 {
3786         enum ice_status status;
3787
3788         if (hashed_flds == ICE_HASH_INVALID ||
3789             !ice_is_vsi_valid(hw, vsi_handle))
3790                 return ICE_ERR_PARAM;
3791
3792         ice_acquire_lock(&hw->rss_locks);
3793         status = ice_rem_rss_cfg_sync(hw, vsi_handle, hashed_flds, addl_hdrs,
3794                                       ICE_RSS_OUTER_HEADERS);
3795         if (!status)
3796                 status = ice_rem_rss_cfg_sync(hw, vsi_handle, hashed_flds,
3797                                               addl_hdrs, ICE_RSS_INNER_HEADERS);
3798         ice_release_lock(&hw->rss_locks);
3799
3800         return status;
3801 }
3802
3803 /**
3804  * ice_replay_rss_cfg - replay RSS configurations associated with VSI
3805  * @hw: pointer to the hardware structure
3806  * @vsi_handle: software VSI handle
3807  */
3808 enum ice_status ice_replay_rss_cfg(struct ice_hw *hw, u16 vsi_handle)
3809 {
3810         enum ice_status status = ICE_SUCCESS;
3811         struct ice_rss_cfg *r;
3812
3813         if (!ice_is_vsi_valid(hw, vsi_handle))
3814                 return ICE_ERR_PARAM;
3815
3816         ice_acquire_lock(&hw->rss_locks);
3817         LIST_FOR_EACH_ENTRY(r, &hw->rss_list_head,
3818                             ice_rss_cfg, l_entry) {
3819                 if (ice_is_bit_set(r->vsis, vsi_handle)) {
3820                         status = ice_add_rss_cfg_sync(hw, vsi_handle,
3821                                                       r->hashed_flds,
3822                                                       r->packet_hdr,
3823                                                       ICE_RSS_OUTER_HEADERS,
3824                                                       r->symm);
3825                         if (status)
3826                                 break;
3827                         status = ice_add_rss_cfg_sync(hw, vsi_handle,
3828                                                       r->hashed_flds,
3829                                                       r->packet_hdr,
3830                                                       ICE_RSS_INNER_HEADERS,
3831                                                       r->symm);
3832                         if (status)
3833                                 break;
3834                 }
3835         }
3836         ice_release_lock(&hw->rss_locks);
3837
3838         return status;
3839 }
3840
3841 /**
3842  * ice_get_rss_cfg - returns hashed fields for the given header types
3843  * @hw: pointer to the hardware structure
3844  * @vsi_handle: software VSI handle
3845  * @hdrs: protocol header type
3846  *
3847  * This function will return the match fields of the first instance of flow
3848  * profile having the given header types and containing input VSI
3849  */
3850 u64 ice_get_rss_cfg(struct ice_hw *hw, u16 vsi_handle, u32 hdrs)
3851 {
3852         u64 rss_hash = ICE_HASH_INVALID;
3853         struct ice_rss_cfg *r;
3854
3855         /* verify if the protocol header is non zero and VSI is valid */
3856         if (hdrs == ICE_FLOW_SEG_HDR_NONE || !ice_is_vsi_valid(hw, vsi_handle))
3857                 return ICE_HASH_INVALID;
3858
3859         ice_acquire_lock(&hw->rss_locks);
3860         LIST_FOR_EACH_ENTRY(r, &hw->rss_list_head,
3861                             ice_rss_cfg, l_entry)
3862                 if (ice_is_bit_set(r->vsis, vsi_handle) &&
3863                     r->packet_hdr == hdrs) {
3864                         rss_hash = r->hashed_flds;
3865                         break;
3866                 }
3867         ice_release_lock(&hw->rss_locks);
3868
3869         return rss_hash;
3870 }