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