1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2001-2021 Intel Corporation 3 */ 4 5 #include "ice_switch.h" 6 #include "ice_flex_type.h" 7 #include "ice_flow.h" 8 9 #define ICE_ETH_DA_OFFSET 0 10 #define ICE_ETH_ETHTYPE_OFFSET 12 11 #define ICE_ETH_VLAN_TCI_OFFSET 14 12 #define ICE_MAX_VLAN_ID 0xFFF 13 #define ICE_IPV4_NVGRE_PROTO_ID 0x002F 14 #define ICE_PPP_IPV6_PROTO_ID 0x0057 15 #define ICE_IPV6_ETHER_ID 0x86DD 16 #define ICE_TCP_PROTO_ID 0x06 17 #define ICE_ETH_P_8021Q 0x8100 18 19 /* Dummy ethernet header needed in the ice_aqc_sw_rules_elem 20 * struct to configure any switch filter rules. 21 * {DA (6 bytes), SA(6 bytes), 22 * Ether type (2 bytes for header without VLAN tag) OR 23 * VLAN tag (4 bytes for header with VLAN tag) } 24 * 25 * Word on Hardcoded values 26 * byte 0 = 0x2: to identify it as locally administered DA MAC 27 * byte 6 = 0x2: to identify it as locally administered SA MAC 28 * byte 12 = 0x81 & byte 13 = 0x00: 29 * In case of VLAN filter first two bytes defines ether type (0x8100) 30 * and remaining two bytes are placeholder for programming a given VLAN ID 31 * In case of Ether type filter it is treated as header without VLAN tag 32 * and byte 12 and 13 is used to program a given Ether type instead 33 */ 34 static const u8 dummy_eth_header[DUMMY_ETH_HDR_LEN] = { 0x2, 0, 0, 0, 0, 0, 35 0x2, 0, 0, 0, 0, 0, 36 0x81, 0, 0, 0}; 37 38 struct ice_dummy_pkt_offsets { 39 enum ice_protocol_type type; 40 u16 offset; /* ICE_PROTOCOL_LAST indicates end of list */ 41 }; 42 43 static const struct ice_dummy_pkt_offsets dummy_gre_tcp_packet_offsets[] = { 44 { ICE_MAC_OFOS, 0 }, 45 { ICE_ETYPE_OL, 12 }, 46 { ICE_IPV4_OFOS, 14 }, 47 { ICE_NVGRE, 34 }, 48 { ICE_MAC_IL, 42 }, 49 { ICE_IPV4_IL, 56 }, 50 { ICE_TCP_IL, 76 }, 51 { ICE_PROTOCOL_LAST, 0 }, 52 }; 53 54 static const u8 dummy_gre_tcp_packet[] = { 55 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 56 0x00, 0x00, 0x00, 0x00, 57 0x00, 0x00, 0x00, 0x00, 58 59 0x08, 0x00, /* ICE_ETYPE_OL 12 */ 60 61 0x45, 0x00, 0x00, 0x3E, /* ICE_IPV4_OFOS 14 */ 62 0x00, 0x00, 0x00, 0x00, 63 0x00, 0x2F, 0x00, 0x00, 64 0x00, 0x00, 0x00, 0x00, 65 0x00, 0x00, 0x00, 0x00, 66 67 0x80, 0x00, 0x65, 0x58, /* ICE_NVGRE 34 */ 68 0x00, 0x00, 0x00, 0x00, 69 70 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_IL 42 */ 71 0x00, 0x00, 0x00, 0x00, 72 0x00, 0x00, 0x00, 0x00, 73 0x08, 0x00, 74 75 0x45, 0x00, 0x00, 0x14, /* ICE_IPV4_IL 56 */ 76 0x00, 0x00, 0x00, 0x00, 77 0x00, 0x06, 0x00, 0x00, 78 0x00, 0x00, 0x00, 0x00, 79 0x00, 0x00, 0x00, 0x00, 80 81 0x00, 0x00, 0x00, 0x00, /* ICE_TCP_IL 76 */ 82 0x00, 0x00, 0x00, 0x00, 83 0x00, 0x00, 0x00, 0x00, 84 0x50, 0x02, 0x20, 0x00, 85 0x00, 0x00, 0x00, 0x00 86 }; 87 88 static const struct ice_dummy_pkt_offsets dummy_gre_udp_packet_offsets[] = { 89 { ICE_MAC_OFOS, 0 }, 90 { ICE_ETYPE_OL, 12 }, 91 { ICE_IPV4_OFOS, 14 }, 92 { ICE_NVGRE, 34 }, 93 { ICE_MAC_IL, 42 }, 94 { ICE_IPV4_IL, 56 }, 95 { ICE_UDP_ILOS, 76 }, 96 { ICE_PROTOCOL_LAST, 0 }, 97 }; 98 99 static const u8 dummy_gre_udp_packet[] = { 100 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 101 0x00, 0x00, 0x00, 0x00, 102 0x00, 0x00, 0x00, 0x00, 103 104 0x08, 0x00, /* ICE_ETYPE_OL 12 */ 105 106 0x45, 0x00, 0x00, 0x3E, /* ICE_IPV4_OFOS 14 */ 107 0x00, 0x00, 0x00, 0x00, 108 0x00, 0x2F, 0x00, 0x00, 109 0x00, 0x00, 0x00, 0x00, 110 0x00, 0x00, 0x00, 0x00, 111 112 0x80, 0x00, 0x65, 0x58, /* ICE_NVGRE 34 */ 113 0x00, 0x00, 0x00, 0x00, 114 115 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_IL 42 */ 116 0x00, 0x00, 0x00, 0x00, 117 0x00, 0x00, 0x00, 0x00, 118 0x08, 0x00, 119 120 0x45, 0x00, 0x00, 0x14, /* ICE_IPV4_IL 56 */ 121 0x00, 0x00, 0x00, 0x00, 122 0x00, 0x11, 0x00, 0x00, 123 0x00, 0x00, 0x00, 0x00, 124 0x00, 0x00, 0x00, 0x00, 125 126 0x00, 0x00, 0x00, 0x00, /* ICE_UDP_ILOS 76 */ 127 0x00, 0x08, 0x00, 0x00, 128 }; 129 130 static const struct ice_dummy_pkt_offsets dummy_udp_tun_tcp_packet_offsets[] = { 131 { ICE_MAC_OFOS, 0 }, 132 { ICE_ETYPE_OL, 12 }, 133 { ICE_IPV4_OFOS, 14 }, 134 { ICE_UDP_OF, 34 }, 135 { ICE_VXLAN, 42 }, 136 { ICE_GENEVE, 42 }, 137 { ICE_VXLAN_GPE, 42 }, 138 { ICE_MAC_IL, 50 }, 139 { ICE_IPV4_IL, 64 }, 140 { ICE_TCP_IL, 84 }, 141 { ICE_PROTOCOL_LAST, 0 }, 142 }; 143 144 static const u8 dummy_udp_tun_tcp_packet[] = { 145 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 146 0x00, 0x00, 0x00, 0x00, 147 0x00, 0x00, 0x00, 0x00, 148 149 0x08, 0x00, /* ICE_ETYPE_OL 12 */ 150 151 0x45, 0x00, 0x00, 0x5a, /* ICE_IPV4_OFOS 14 */ 152 0x00, 0x01, 0x00, 0x00, 153 0x40, 0x11, 0x00, 0x00, 154 0x00, 0x00, 0x00, 0x00, 155 0x00, 0x00, 0x00, 0x00, 156 157 0x00, 0x00, 0x12, 0xb5, /* ICE_UDP_OF 34 */ 158 0x00, 0x46, 0x00, 0x00, 159 160 0x00, 0x00, 0x65, 0x58, /* ICE_VXLAN 42 */ 161 0x00, 0x00, 0x00, 0x00, 162 163 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_IL 50 */ 164 0x00, 0x00, 0x00, 0x00, 165 0x00, 0x00, 0x00, 0x00, 166 0x08, 0x00, 167 168 0x45, 0x00, 0x00, 0x28, /* ICE_IPV4_IL 64 */ 169 0x00, 0x01, 0x00, 0x00, 170 0x40, 0x06, 0x00, 0x00, 171 0x00, 0x00, 0x00, 0x00, 172 0x00, 0x00, 0x00, 0x00, 173 174 0x00, 0x00, 0x00, 0x00, /* ICE_TCP_IL 84 */ 175 0x00, 0x00, 0x00, 0x00, 176 0x00, 0x00, 0x00, 0x00, 177 0x50, 0x02, 0x20, 0x00, 178 0x00, 0x00, 0x00, 0x00 179 }; 180 181 static const struct ice_dummy_pkt_offsets dummy_udp_tun_udp_packet_offsets[] = { 182 { ICE_MAC_OFOS, 0 }, 183 { ICE_ETYPE_OL, 12 }, 184 { ICE_IPV4_OFOS, 14 }, 185 { ICE_UDP_OF, 34 }, 186 { ICE_VXLAN, 42 }, 187 { ICE_GENEVE, 42 }, 188 { ICE_VXLAN_GPE, 42 }, 189 { ICE_MAC_IL, 50 }, 190 { ICE_IPV4_IL, 64 }, 191 { ICE_UDP_ILOS, 84 }, 192 { ICE_PROTOCOL_LAST, 0 }, 193 }; 194 195 static const u8 dummy_udp_tun_udp_packet[] = { 196 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 197 0x00, 0x00, 0x00, 0x00, 198 0x00, 0x00, 0x00, 0x00, 199 200 0x08, 0x00, /* ICE_ETYPE_OL 12 */ 201 202 0x45, 0x00, 0x00, 0x4e, /* ICE_IPV4_OFOS 14 */ 203 0x00, 0x01, 0x00, 0x00, 204 0x00, 0x11, 0x00, 0x00, 205 0x00, 0x00, 0x00, 0x00, 206 0x00, 0x00, 0x00, 0x00, 207 208 0x00, 0x00, 0x12, 0xb5, /* ICE_UDP_OF 34 */ 209 0x00, 0x3a, 0x00, 0x00, 210 211 0x00, 0x00, 0x65, 0x58, /* ICE_VXLAN 42 */ 212 0x00, 0x00, 0x00, 0x00, 213 214 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_IL 50 */ 215 0x00, 0x00, 0x00, 0x00, 216 0x00, 0x00, 0x00, 0x00, 217 0x08, 0x00, 218 219 0x45, 0x00, 0x00, 0x1c, /* ICE_IPV4_IL 64 */ 220 0x00, 0x01, 0x00, 0x00, 221 0x00, 0x11, 0x00, 0x00, 222 0x00, 0x00, 0x00, 0x00, 223 0x00, 0x00, 0x00, 0x00, 224 225 0x00, 0x00, 0x00, 0x00, /* ICE_UDP_ILOS 84 */ 226 0x00, 0x08, 0x00, 0x00, 227 }; 228 229 /* offset info for MAC + IPv4 + UDP dummy packet */ 230 static const struct ice_dummy_pkt_offsets dummy_udp_packet_offsets[] = { 231 { ICE_MAC_OFOS, 0 }, 232 { ICE_ETYPE_OL, 12 }, 233 { ICE_IPV4_OFOS, 14 }, 234 { ICE_UDP_ILOS, 34 }, 235 { ICE_PROTOCOL_LAST, 0 }, 236 }; 237 238 /* Dummy packet for MAC + IPv4 + UDP */ 239 static const u8 dummy_udp_packet[] = { 240 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 241 0x00, 0x00, 0x00, 0x00, 242 0x00, 0x00, 0x00, 0x00, 243 244 0x08, 0x00, /* ICE_ETYPE_OL 12 */ 245 246 0x45, 0x00, 0x00, 0x1c, /* ICE_IPV4_OFOS 14 */ 247 0x00, 0x01, 0x00, 0x00, 248 0x00, 0x11, 0x00, 0x00, 249 0x00, 0x00, 0x00, 0x00, 250 0x00, 0x00, 0x00, 0x00, 251 252 0x00, 0x00, 0x00, 0x00, /* ICE_UDP_ILOS 34 */ 253 0x00, 0x08, 0x00, 0x00, 254 255 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 256 }; 257 258 /* offset info for MAC + VLAN + IPv4 + UDP dummy packet */ 259 static const struct ice_dummy_pkt_offsets dummy_vlan_udp_packet_offsets[] = { 260 { ICE_MAC_OFOS, 0 }, 261 { ICE_ETYPE_OL, 12 }, 262 { ICE_VLAN_OFOS, 14 }, 263 { ICE_IPV4_OFOS, 18 }, 264 { ICE_UDP_ILOS, 38 }, 265 { ICE_PROTOCOL_LAST, 0 }, 266 }; 267 268 /* C-tag (801.1Q), IPv4:UDP dummy packet */ 269 static const u8 dummy_vlan_udp_packet[] = { 270 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 271 0x00, 0x00, 0x00, 0x00, 272 0x00, 0x00, 0x00, 0x00, 273 274 0x81, 0x00, /* ICE_ETYPE_OL 12 */ 275 276 0x00, 0x00, 0x08, 0x00, /* ICE_VLAN_OFOS 14 */ 277 278 0x45, 0x00, 0x00, 0x1c, /* ICE_IPV4_OFOS 18 */ 279 0x00, 0x01, 0x00, 0x00, 280 0x00, 0x11, 0x00, 0x00, 281 0x00, 0x00, 0x00, 0x00, 282 0x00, 0x00, 0x00, 0x00, 283 284 0x00, 0x00, 0x00, 0x00, /* ICE_UDP_ILOS 38 */ 285 0x00, 0x08, 0x00, 0x00, 286 287 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 288 }; 289 290 /* offset info for MAC + IPv4 + TCP dummy packet */ 291 static const struct ice_dummy_pkt_offsets dummy_tcp_packet_offsets[] = { 292 { ICE_MAC_OFOS, 0 }, 293 { ICE_ETYPE_OL, 12 }, 294 { ICE_IPV4_OFOS, 14 }, 295 { ICE_TCP_IL, 34 }, 296 { ICE_PROTOCOL_LAST, 0 }, 297 }; 298 299 /* Dummy packet for MAC + IPv4 + TCP */ 300 static const u8 dummy_tcp_packet[] = { 301 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 302 0x00, 0x00, 0x00, 0x00, 303 0x00, 0x00, 0x00, 0x00, 304 305 0x08, 0x00, /* ICE_ETYPE_OL 12 */ 306 307 0x45, 0x00, 0x00, 0x28, /* ICE_IPV4_OFOS 14 */ 308 0x00, 0x01, 0x00, 0x00, 309 0x00, 0x06, 0x00, 0x00, 310 0x00, 0x00, 0x00, 0x00, 311 0x00, 0x00, 0x00, 0x00, 312 313 0x00, 0x00, 0x00, 0x00, /* ICE_TCP_IL 34 */ 314 0x00, 0x00, 0x00, 0x00, 315 0x00, 0x00, 0x00, 0x00, 316 0x50, 0x00, 0x00, 0x00, 317 0x00, 0x00, 0x00, 0x00, 318 319 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 320 }; 321 322 /* offset info for MAC + VLAN (C-tag, 802.1Q) + IPv4 + TCP dummy packet */ 323 static const struct ice_dummy_pkt_offsets dummy_vlan_tcp_packet_offsets[] = { 324 { ICE_MAC_OFOS, 0 }, 325 { ICE_ETYPE_OL, 12 }, 326 { ICE_VLAN_OFOS, 14 }, 327 { ICE_IPV4_OFOS, 18 }, 328 { ICE_TCP_IL, 38 }, 329 { ICE_PROTOCOL_LAST, 0 }, 330 }; 331 332 /* C-tag (801.1Q), IPv4:TCP dummy packet */ 333 static const u8 dummy_vlan_tcp_packet[] = { 334 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 335 0x00, 0x00, 0x00, 0x00, 336 0x00, 0x00, 0x00, 0x00, 337 338 0x81, 0x00, /* ICE_ETYPE_OL 12 */ 339 340 0x00, 0x00, 0x08, 0x00, /* ICE_VLAN_OFOS 14 */ 341 342 0x45, 0x00, 0x00, 0x28, /* ICE_IPV4_OFOS 18 */ 343 0x00, 0x01, 0x00, 0x00, 344 0x00, 0x06, 0x00, 0x00, 345 0x00, 0x00, 0x00, 0x00, 346 0x00, 0x00, 0x00, 0x00, 347 348 0x00, 0x00, 0x00, 0x00, /* ICE_TCP_IL 38 */ 349 0x00, 0x00, 0x00, 0x00, 350 0x00, 0x00, 0x00, 0x00, 351 0x50, 0x00, 0x00, 0x00, 352 0x00, 0x00, 0x00, 0x00, 353 354 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 355 }; 356 357 static const struct ice_dummy_pkt_offsets dummy_tcp_ipv6_packet_offsets[] = { 358 { ICE_MAC_OFOS, 0 }, 359 { ICE_ETYPE_OL, 12 }, 360 { ICE_IPV6_OFOS, 14 }, 361 { ICE_TCP_IL, 54 }, 362 { ICE_PROTOCOL_LAST, 0 }, 363 }; 364 365 static const u8 dummy_tcp_ipv6_packet[] = { 366 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 367 0x00, 0x00, 0x00, 0x00, 368 0x00, 0x00, 0x00, 0x00, 369 370 0x86, 0xDD, /* ICE_ETYPE_OL 12 */ 371 372 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_OFOS 40 */ 373 0x00, 0x14, 0x06, 0x00, /* Next header is TCP */ 374 0x00, 0x00, 0x00, 0x00, 375 0x00, 0x00, 0x00, 0x00, 376 0x00, 0x00, 0x00, 0x00, 377 0x00, 0x00, 0x00, 0x00, 378 0x00, 0x00, 0x00, 0x00, 379 0x00, 0x00, 0x00, 0x00, 380 0x00, 0x00, 0x00, 0x00, 381 0x00, 0x00, 0x00, 0x00, 382 383 0x00, 0x00, 0x00, 0x00, /* ICE_TCP_IL 54 */ 384 0x00, 0x00, 0x00, 0x00, 385 0x00, 0x00, 0x00, 0x00, 386 0x50, 0x00, 0x00, 0x00, 387 0x00, 0x00, 0x00, 0x00, 388 389 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 390 }; 391 392 /* C-tag (802.1Q): IPv6 + TCP */ 393 static const struct ice_dummy_pkt_offsets 394 dummy_vlan_tcp_ipv6_packet_offsets[] = { 395 { ICE_MAC_OFOS, 0 }, 396 { ICE_ETYPE_OL, 12 }, 397 { ICE_VLAN_OFOS, 14 }, 398 { ICE_IPV6_OFOS, 18 }, 399 { ICE_TCP_IL, 58 }, 400 { ICE_PROTOCOL_LAST, 0 }, 401 }; 402 403 /* C-tag (802.1Q), IPv6 + TCP dummy packet */ 404 static const u8 dummy_vlan_tcp_ipv6_packet[] = { 405 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 406 0x00, 0x00, 0x00, 0x00, 407 0x00, 0x00, 0x00, 0x00, 408 409 0x81, 0x00, /* ICE_ETYPE_OL 12 */ 410 411 0x00, 0x00, 0x86, 0xDD, /* ICE_VLAN_OFOS 14 */ 412 413 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_OFOS 18 */ 414 0x00, 0x14, 0x06, 0x00, /* Next header is TCP */ 415 0x00, 0x00, 0x00, 0x00, 416 0x00, 0x00, 0x00, 0x00, 417 0x00, 0x00, 0x00, 0x00, 418 0x00, 0x00, 0x00, 0x00, 419 0x00, 0x00, 0x00, 0x00, 420 0x00, 0x00, 0x00, 0x00, 421 0x00, 0x00, 0x00, 0x00, 422 0x00, 0x00, 0x00, 0x00, 423 424 0x00, 0x00, 0x00, 0x00, /* ICE_TCP_IL 58 */ 425 0x00, 0x00, 0x00, 0x00, 426 0x00, 0x00, 0x00, 0x00, 427 0x50, 0x00, 0x00, 0x00, 428 0x00, 0x00, 0x00, 0x00, 429 430 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 431 }; 432 433 /* IPv6 + UDP */ 434 static const struct ice_dummy_pkt_offsets dummy_udp_ipv6_packet_offsets[] = { 435 { ICE_MAC_OFOS, 0 }, 436 { ICE_ETYPE_OL, 12 }, 437 { ICE_IPV6_OFOS, 14 }, 438 { ICE_UDP_ILOS, 54 }, 439 { ICE_PROTOCOL_LAST, 0 }, 440 }; 441 442 /* IPv6 + UDP dummy packet */ 443 static const u8 dummy_udp_ipv6_packet[] = { 444 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 445 0x00, 0x00, 0x00, 0x00, 446 0x00, 0x00, 0x00, 0x00, 447 448 0x86, 0xDD, /* ICE_ETYPE_OL 12 */ 449 450 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_OFOS 40 */ 451 0x00, 0x10, 0x11, 0x00, /* Next header UDP */ 452 0x00, 0x00, 0x00, 0x00, 453 0x00, 0x00, 0x00, 0x00, 454 0x00, 0x00, 0x00, 0x00, 455 0x00, 0x00, 0x00, 0x00, 456 0x00, 0x00, 0x00, 0x00, 457 0x00, 0x00, 0x00, 0x00, 458 0x00, 0x00, 0x00, 0x00, 459 0x00, 0x00, 0x00, 0x00, 460 461 0x00, 0x00, 0x00, 0x00, /* ICE_UDP_ILOS 54 */ 462 0x00, 0x10, 0x00, 0x00, 463 464 0x00, 0x00, 0x00, 0x00, /* needed for ESP packets */ 465 0x00, 0x00, 0x00, 0x00, 466 467 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 468 }; 469 470 /* C-tag (802.1Q): IPv6 + UDP */ 471 static const struct ice_dummy_pkt_offsets 472 dummy_vlan_udp_ipv6_packet_offsets[] = { 473 { ICE_MAC_OFOS, 0 }, 474 { ICE_ETYPE_OL, 12 }, 475 { ICE_VLAN_OFOS, 14 }, 476 { ICE_IPV6_OFOS, 18 }, 477 { ICE_UDP_ILOS, 58 }, 478 { ICE_PROTOCOL_LAST, 0 }, 479 }; 480 481 /* C-tag (802.1Q), IPv6 + UDP dummy packet */ 482 static const u8 dummy_vlan_udp_ipv6_packet[] = { 483 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 484 0x00, 0x00, 0x00, 0x00, 485 0x00, 0x00, 0x00, 0x00, 486 487 0x81, 0x00, /* ICE_ETYPE_OL 12 */ 488 489 0x00, 0x00, 0x86, 0xDD, /* ICE_VLAN_OFOS 14 */ 490 491 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_OFOS 18 */ 492 0x00, 0x08, 0x11, 0x00, /* Next header UDP */ 493 0x00, 0x00, 0x00, 0x00, 494 0x00, 0x00, 0x00, 0x00, 495 0x00, 0x00, 0x00, 0x00, 496 0x00, 0x00, 0x00, 0x00, 497 0x00, 0x00, 0x00, 0x00, 498 0x00, 0x00, 0x00, 0x00, 499 0x00, 0x00, 0x00, 0x00, 500 0x00, 0x00, 0x00, 0x00, 501 502 0x00, 0x00, 0x00, 0x00, /* ICE_UDP_ILOS 58 */ 503 0x00, 0x08, 0x00, 0x00, 504 505 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 506 }; 507 508 /* Outer IPv4 + Outer UDP + GTP + Inner IPv4 + Inner TCP */ 509 static const struct ice_dummy_pkt_offsets dummy_ipv4_gtpu_ipv4_tcp_packet_offsets[] = { 510 { ICE_MAC_OFOS, 0 }, 511 { ICE_IPV4_OFOS, 14 }, 512 { ICE_UDP_OF, 34 }, 513 { ICE_GTP, 42 }, 514 { ICE_IPV4_IL, 62 }, 515 { ICE_TCP_IL, 82 }, 516 { ICE_PROTOCOL_LAST, 0 }, 517 }; 518 519 static const u8 dummy_ipv4_gtpu_ipv4_tcp_packet[] = { 520 0x00, 0x00, 0x00, 0x00, /* Ethernet 0 */ 521 0x00, 0x00, 0x00, 0x00, 522 0x00, 0x00, 0x00, 0x00, 523 0x08, 0x00, 524 525 0x45, 0x00, 0x00, 0x58, /* IP 14 */ 526 0x00, 0x00, 0x00, 0x00, 527 0x00, 0x11, 0x00, 0x00, 528 0x00, 0x00, 0x00, 0x00, 529 0x00, 0x00, 0x00, 0x00, 530 531 0x00, 0x00, 0x08, 0x68, /* UDP 34 */ 532 0x00, 0x44, 0x00, 0x00, 533 534 0x34, 0xff, 0x00, 0x34, /* GTP-U Header 42 */ 535 0x00, 0x00, 0x00, 0x00, 536 0x00, 0x00, 0x00, 0x85, 537 538 0x02, 0x00, 0x00, 0x00, /* GTP_PDUSession_ExtensionHeader 54 */ 539 0x00, 0x00, 0x00, 0x00, 540 541 0x45, 0x00, 0x00, 0x28, /* IP 62 */ 542 0x00, 0x00, 0x00, 0x00, 543 0x00, 0x06, 0x00, 0x00, 544 0x00, 0x00, 0x00, 0x00, 545 0x00, 0x00, 0x00, 0x00, 546 547 0x00, 0x00, 0x00, 0x00, /* TCP 82 */ 548 0x00, 0x00, 0x00, 0x00, 549 0x00, 0x00, 0x00, 0x00, 550 0x50, 0x00, 0x00, 0x00, 551 0x00, 0x00, 0x00, 0x00, 552 553 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 554 }; 555 556 /* Outer IPv4 + Outer UDP + GTP + Inner IPv4 + Inner UDP */ 557 static const struct ice_dummy_pkt_offsets dummy_ipv4_gtpu_ipv4_udp_packet_offsets[] = { 558 { ICE_MAC_OFOS, 0 }, 559 { ICE_IPV4_OFOS, 14 }, 560 { ICE_UDP_OF, 34 }, 561 { ICE_GTP, 42 }, 562 { ICE_IPV4_IL, 62 }, 563 { ICE_UDP_ILOS, 82 }, 564 { ICE_PROTOCOL_LAST, 0 }, 565 }; 566 567 static const u8 dummy_ipv4_gtpu_ipv4_udp_packet[] = { 568 0x00, 0x00, 0x00, 0x00, /* Ethernet 0 */ 569 0x00, 0x00, 0x00, 0x00, 570 0x00, 0x00, 0x00, 0x00, 571 0x08, 0x00, 572 573 0x45, 0x00, 0x00, 0x4c, /* IP 14 */ 574 0x00, 0x00, 0x00, 0x00, 575 0x00, 0x11, 0x00, 0x00, 576 0x00, 0x00, 0x00, 0x00, 577 0x00, 0x00, 0x00, 0x00, 578 579 0x00, 0x00, 0x08, 0x68, /* UDP 34 */ 580 0x00, 0x38, 0x00, 0x00, 581 582 0x34, 0xff, 0x00, 0x28, /* GTP-U Header 42 */ 583 0x00, 0x00, 0x00, 0x00, 584 0x00, 0x00, 0x00, 0x85, 585 586 0x02, 0x00, 0x00, 0x00, /* GTP_PDUSession_ExtensionHeader 54 */ 587 0x00, 0x00, 0x00, 0x00, 588 589 0x45, 0x00, 0x00, 0x1c, /* IP 62 */ 590 0x00, 0x00, 0x00, 0x00, 591 0x00, 0x11, 0x00, 0x00, 592 0x00, 0x00, 0x00, 0x00, 593 0x00, 0x00, 0x00, 0x00, 594 595 0x00, 0x00, 0x00, 0x00, /* UDP 82 */ 596 0x00, 0x08, 0x00, 0x00, 597 598 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 599 }; 600 601 /* Outer IPv6 + Outer UDP + GTP + Inner IPv4 + Inner TCP */ 602 static const struct ice_dummy_pkt_offsets dummy_ipv4_gtpu_ipv6_tcp_packet_offsets[] = { 603 { ICE_MAC_OFOS, 0 }, 604 { ICE_IPV4_OFOS, 14 }, 605 { ICE_UDP_OF, 34 }, 606 { ICE_GTP, 42 }, 607 { ICE_IPV6_IL, 62 }, 608 { ICE_TCP_IL, 102 }, 609 { ICE_PROTOCOL_LAST, 0 }, 610 }; 611 612 static const u8 dummy_ipv4_gtpu_ipv6_tcp_packet[] = { 613 0x00, 0x00, 0x00, 0x00, /* Ethernet 0 */ 614 0x00, 0x00, 0x00, 0x00, 615 0x00, 0x00, 0x00, 0x00, 616 0x08, 0x00, 617 618 0x45, 0x00, 0x00, 0x6c, /* IP 14 */ 619 0x00, 0x00, 0x00, 0x00, 620 0x00, 0x11, 0x00, 0x00, 621 0x00, 0x00, 0x00, 0x00, 622 0x00, 0x00, 0x00, 0x00, 623 624 0x00, 0x00, 0x08, 0x68, /* UDP 34 */ 625 0x00, 0x58, 0x00, 0x00, 626 627 0x34, 0xff, 0x00, 0x48, /* GTP-U Header 42 */ 628 0x00, 0x00, 0x00, 0x00, 629 0x00, 0x00, 0x00, 0x85, 630 631 0x02, 0x00, 0x00, 0x00, /* GTP_PDUSession_ExtensionHeader 54 */ 632 0x00, 0x00, 0x00, 0x00, 633 634 0x60, 0x00, 0x00, 0x00, /* IPv6 62 */ 635 0x00, 0x14, 0x06, 0x00, 636 0x00, 0x00, 0x00, 0x00, 637 0x00, 0x00, 0x00, 0x00, 638 0x00, 0x00, 0x00, 0x00, 639 0x00, 0x00, 0x00, 0x00, 640 0x00, 0x00, 0x00, 0x00, 641 0x00, 0x00, 0x00, 0x00, 642 0x00, 0x00, 0x00, 0x00, 643 0x00, 0x00, 0x00, 0x00, 644 645 0x00, 0x00, 0x00, 0x00, /* TCP 102 */ 646 0x00, 0x00, 0x00, 0x00, 647 0x00, 0x00, 0x00, 0x00, 648 0x50, 0x00, 0x00, 0x00, 649 0x00, 0x00, 0x00, 0x00, 650 651 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 652 }; 653 654 static const struct ice_dummy_pkt_offsets dummy_ipv4_gtpu_ipv6_udp_packet_offsets[] = { 655 { ICE_MAC_OFOS, 0 }, 656 { ICE_IPV4_OFOS, 14 }, 657 { ICE_UDP_OF, 34 }, 658 { ICE_GTP, 42 }, 659 { ICE_IPV6_IL, 62 }, 660 { ICE_UDP_ILOS, 102 }, 661 { ICE_PROTOCOL_LAST, 0 }, 662 }; 663 664 static const u8 dummy_ipv4_gtpu_ipv6_udp_packet[] = { 665 0x00, 0x00, 0x00, 0x00, /* Ethernet 0 */ 666 0x00, 0x00, 0x00, 0x00, 667 0x00, 0x00, 0x00, 0x00, 668 0x08, 0x00, 669 670 0x45, 0x00, 0x00, 0x60, /* IP 14 */ 671 0x00, 0x00, 0x00, 0x00, 672 0x00, 0x11, 0x00, 0x00, 673 0x00, 0x00, 0x00, 0x00, 674 0x00, 0x00, 0x00, 0x00, 675 676 0x00, 0x00, 0x08, 0x68, /* UDP 34 */ 677 0x00, 0x4c, 0x00, 0x00, 678 679 0x34, 0xff, 0x00, 0x3c, /* GTP-U Header 42 */ 680 0x00, 0x00, 0x00, 0x00, 681 0x00, 0x00, 0x00, 0x85, 682 683 0x02, 0x00, 0x00, 0x00, /* GTP_PDUSession_ExtensionHeader 54 */ 684 0x00, 0x00, 0x00, 0x00, 685 686 0x60, 0x00, 0x00, 0x00, /* IPv6 62 */ 687 0x00, 0x08, 0x11, 0x00, 688 0x00, 0x00, 0x00, 0x00, 689 0x00, 0x00, 0x00, 0x00, 690 0x00, 0x00, 0x00, 0x00, 691 0x00, 0x00, 0x00, 0x00, 692 0x00, 0x00, 0x00, 0x00, 693 0x00, 0x00, 0x00, 0x00, 694 0x00, 0x00, 0x00, 0x00, 695 0x00, 0x00, 0x00, 0x00, 696 697 0x00, 0x00, 0x00, 0x00, /* UDP 102 */ 698 0x00, 0x08, 0x00, 0x00, 699 700 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 701 }; 702 703 static const struct ice_dummy_pkt_offsets dummy_ipv6_gtpu_ipv4_tcp_packet_offsets[] = { 704 { ICE_MAC_OFOS, 0 }, 705 { ICE_IPV6_OFOS, 14 }, 706 { ICE_UDP_OF, 54 }, 707 { ICE_GTP, 62 }, 708 { ICE_IPV4_IL, 82 }, 709 { ICE_TCP_IL, 102 }, 710 { ICE_PROTOCOL_LAST, 0 }, 711 }; 712 713 static const u8 dummy_ipv6_gtpu_ipv4_tcp_packet[] = { 714 0x00, 0x00, 0x00, 0x00, /* Ethernet 0 */ 715 0x00, 0x00, 0x00, 0x00, 716 0x00, 0x00, 0x00, 0x00, 717 0x86, 0xdd, 718 719 0x60, 0x00, 0x00, 0x00, /* IPv6 14 */ 720 0x00, 0x44, 0x11, 0x00, 721 0x00, 0x00, 0x00, 0x00, 722 0x00, 0x00, 0x00, 0x00, 723 0x00, 0x00, 0x00, 0x00, 724 0x00, 0x00, 0x00, 0x00, 725 0x00, 0x00, 0x00, 0x00, 726 0x00, 0x00, 0x00, 0x00, 727 0x00, 0x00, 0x00, 0x00, 728 0x00, 0x00, 0x00, 0x00, 729 730 0x00, 0x00, 0x08, 0x68, /* UDP 54 */ 731 0x00, 0x44, 0x00, 0x00, 732 733 0x34, 0xff, 0x00, 0x34, /* GTP-U Header 62 */ 734 0x00, 0x00, 0x00, 0x00, 735 0x00, 0x00, 0x00, 0x85, 736 737 0x02, 0x00, 0x00, 0x00, /* GTP_PDUSession_ExtensionHeader 74 */ 738 0x00, 0x00, 0x00, 0x00, 739 740 0x45, 0x00, 0x00, 0x28, /* IP 82 */ 741 0x00, 0x00, 0x00, 0x00, 742 0x00, 0x06, 0x00, 0x00, 743 0x00, 0x00, 0x00, 0x00, 744 0x00, 0x00, 0x00, 0x00, 745 746 0x00, 0x00, 0x00, 0x00, /* TCP 102 */ 747 0x00, 0x00, 0x00, 0x00, 748 0x00, 0x00, 0x00, 0x00, 749 0x50, 0x00, 0x00, 0x00, 750 0x00, 0x00, 0x00, 0x00, 751 752 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 753 }; 754 755 static const struct ice_dummy_pkt_offsets dummy_ipv6_gtpu_ipv4_udp_packet_offsets[] = { 756 { ICE_MAC_OFOS, 0 }, 757 { ICE_IPV6_OFOS, 14 }, 758 { ICE_UDP_OF, 54 }, 759 { ICE_GTP, 62 }, 760 { ICE_IPV4_IL, 82 }, 761 { ICE_UDP_ILOS, 102 }, 762 { ICE_PROTOCOL_LAST, 0 }, 763 }; 764 765 static const u8 dummy_ipv6_gtpu_ipv4_udp_packet[] = { 766 0x00, 0x00, 0x00, 0x00, /* Ethernet 0 */ 767 0x00, 0x00, 0x00, 0x00, 768 0x00, 0x00, 0x00, 0x00, 769 0x86, 0xdd, 770 771 0x60, 0x00, 0x00, 0x00, /* IPv6 14 */ 772 0x00, 0x38, 0x11, 0x00, 773 0x00, 0x00, 0x00, 0x00, 774 0x00, 0x00, 0x00, 0x00, 775 0x00, 0x00, 0x00, 0x00, 776 0x00, 0x00, 0x00, 0x00, 777 0x00, 0x00, 0x00, 0x00, 778 0x00, 0x00, 0x00, 0x00, 779 0x00, 0x00, 0x00, 0x00, 780 0x00, 0x00, 0x00, 0x00, 781 782 0x00, 0x00, 0x08, 0x68, /* UDP 54 */ 783 0x00, 0x38, 0x00, 0x00, 784 785 0x34, 0xff, 0x00, 0x28, /* GTP-U Header 62 */ 786 0x00, 0x00, 0x00, 0x00, 787 0x00, 0x00, 0x00, 0x85, 788 789 0x02, 0x00, 0x00, 0x00, /* GTP_PDUSession_ExtensionHeader 74 */ 790 0x00, 0x00, 0x00, 0x00, 791 792 0x45, 0x00, 0x00, 0x1c, /* IP 82 */ 793 0x00, 0x00, 0x00, 0x00, 794 0x00, 0x11, 0x00, 0x00, 795 0x00, 0x00, 0x00, 0x00, 796 0x00, 0x00, 0x00, 0x00, 797 798 0x00, 0x00, 0x00, 0x00, /* UDP 102 */ 799 0x00, 0x08, 0x00, 0x00, 800 801 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 802 }; 803 804 static const struct ice_dummy_pkt_offsets dummy_ipv6_gtpu_ipv6_tcp_packet_offsets[] = { 805 { ICE_MAC_OFOS, 0 }, 806 { ICE_IPV6_OFOS, 14 }, 807 { ICE_UDP_OF, 54 }, 808 { ICE_GTP, 62 }, 809 { ICE_IPV6_IL, 82 }, 810 { ICE_TCP_IL, 102 }, 811 { ICE_PROTOCOL_LAST, 0 }, 812 }; 813 814 static const u8 dummy_ipv6_gtpu_ipv6_tcp_packet[] = { 815 0x00, 0x00, 0x00, 0x00, /* Ethernet 0 */ 816 0x00, 0x00, 0x00, 0x00, 817 0x00, 0x00, 0x00, 0x00, 818 0x86, 0xdd, 819 820 0x60, 0x00, 0x00, 0x00, /* IPv6 14 */ 821 0x00, 0x58, 0x11, 0x00, 822 0x00, 0x00, 0x00, 0x00, 823 0x00, 0x00, 0x00, 0x00, 824 0x00, 0x00, 0x00, 0x00, 825 0x00, 0x00, 0x00, 0x00, 826 0x00, 0x00, 0x00, 0x00, 827 0x00, 0x00, 0x00, 0x00, 828 0x00, 0x00, 0x00, 0x00, 829 0x00, 0x00, 0x00, 0x00, 830 831 0x00, 0x00, 0x08, 0x68, /* UDP 54 */ 832 0x00, 0x58, 0x00, 0x00, 833 834 0x34, 0xff, 0x00, 0x48, /* GTP-U Header 62 */ 835 0x00, 0x00, 0x00, 0x00, 836 0x00, 0x00, 0x00, 0x85, 837 838 0x02, 0x00, 0x00, 0x00, /* GTP_PDUSession_ExtensionHeader 74 */ 839 0x00, 0x00, 0x00, 0x00, 840 841 0x60, 0x00, 0x00, 0x00, /* IPv6 82 */ 842 0x00, 0x14, 0x06, 0x00, 843 0x00, 0x00, 0x00, 0x00, 844 0x00, 0x00, 0x00, 0x00, 845 0x00, 0x00, 0x00, 0x00, 846 0x00, 0x00, 0x00, 0x00, 847 0x00, 0x00, 0x00, 0x00, 848 0x00, 0x00, 0x00, 0x00, 849 0x00, 0x00, 0x00, 0x00, 850 0x00, 0x00, 0x00, 0x00, 851 852 0x00, 0x00, 0x00, 0x00, /* TCP 122 */ 853 0x00, 0x00, 0x00, 0x00, 854 0x00, 0x00, 0x00, 0x00, 855 0x50, 0x00, 0x00, 0x00, 856 0x00, 0x00, 0x00, 0x00, 857 858 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 859 }; 860 861 static const struct ice_dummy_pkt_offsets dummy_ipv6_gtpu_ipv6_udp_packet_offsets[] = { 862 { ICE_MAC_OFOS, 0 }, 863 { ICE_IPV6_OFOS, 14 }, 864 { ICE_UDP_OF, 54 }, 865 { ICE_GTP, 62 }, 866 { ICE_IPV6_IL, 82 }, 867 { ICE_UDP_ILOS, 102 }, 868 { ICE_PROTOCOL_LAST, 0 }, 869 }; 870 871 static const u8 dummy_ipv6_gtpu_ipv6_udp_packet[] = { 872 0x00, 0x00, 0x00, 0x00, /* Ethernet 0 */ 873 0x00, 0x00, 0x00, 0x00, 874 0x00, 0x00, 0x00, 0x00, 875 0x86, 0xdd, 876 877 0x60, 0x00, 0x00, 0x00, /* IPv6 14 */ 878 0x00, 0x4c, 0x11, 0x00, 879 0x00, 0x00, 0x00, 0x00, 880 0x00, 0x00, 0x00, 0x00, 881 0x00, 0x00, 0x00, 0x00, 882 0x00, 0x00, 0x00, 0x00, 883 0x00, 0x00, 0x00, 0x00, 884 0x00, 0x00, 0x00, 0x00, 885 0x00, 0x00, 0x00, 0x00, 886 0x00, 0x00, 0x00, 0x00, 887 888 0x00, 0x00, 0x08, 0x68, /* UDP 54 */ 889 0x00, 0x4c, 0x00, 0x00, 890 891 0x34, 0xff, 0x00, 0x3c, /* GTP-U Header 62 */ 892 0x00, 0x00, 0x00, 0x00, 893 0x00, 0x00, 0x00, 0x85, 894 895 0x02, 0x00, 0x00, 0x00, /* GTP_PDUSession_ExtensionHeader 74 */ 896 0x00, 0x00, 0x00, 0x00, 897 898 0x60, 0x00, 0x00, 0x00, /* IPv6 82 */ 899 0x00, 0x08, 0x11, 0x00, 900 0x00, 0x00, 0x00, 0x00, 901 0x00, 0x00, 0x00, 0x00, 902 0x00, 0x00, 0x00, 0x00, 903 0x00, 0x00, 0x00, 0x00, 904 0x00, 0x00, 0x00, 0x00, 905 0x00, 0x00, 0x00, 0x00, 906 0x00, 0x00, 0x00, 0x00, 907 0x00, 0x00, 0x00, 0x00, 908 909 0x00, 0x00, 0x00, 0x00, /* UDP 122 */ 910 0x00, 0x08, 0x00, 0x00, 911 912 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 913 }; 914 915 static const struct ice_dummy_pkt_offsets dummy_ipv4_gtpu_ipv4_packet_offsets[] = { 916 { ICE_MAC_OFOS, 0 }, 917 { ICE_IPV4_OFOS, 14 }, 918 { ICE_UDP_OF, 34 }, 919 { ICE_GTP, 42 }, 920 { ICE_IPV4_IL, 62 }, 921 { ICE_PROTOCOL_LAST, 0 }, 922 }; 923 924 static const u8 dummy_ipv4_gtpu_ipv4_packet[] = { 925 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 926 0x00, 0x00, 0x00, 0x00, 927 0x00, 0x00, 0x00, 0x00, 928 0x08, 0x00, 929 930 0x45, 0x00, 0x00, 0x44, /* ICE_IPV4_OFOS 14 */ 931 0x00, 0x00, 0x40, 0x00, 932 0x40, 0x11, 0x00, 0x00, 933 0x00, 0x00, 0x00, 0x00, 934 0x00, 0x00, 0x00, 0x00, 935 936 0x08, 0x68, 0x08, 0x68, /* ICE_UDP_OF 34 */ 937 0x00, 0x00, 0x00, 0x00, 938 939 0x34, 0xff, 0x00, 0x28, /* ICE_GTP 42 */ 940 0x00, 0x00, 0x00, 0x00, 941 0x00, 0x00, 0x00, 0x85, 942 943 0x02, 0x00, 0x00, 0x00, /* PDU Session extension header */ 944 0x00, 0x00, 0x00, 0x00, 945 946 0x45, 0x00, 0x00, 0x14, /* ICE_IPV4_IL 62 */ 947 0x00, 0x00, 0x40, 0x00, 948 0x40, 0x00, 0x00, 0x00, 949 0x00, 0x00, 0x00, 0x00, 950 0x00, 0x00, 0x00, 0x00, 951 0x00, 0x00, 952 }; 953 954 static const 955 struct ice_dummy_pkt_offsets dummy_ipv4_gtpu_ipv6_packet_offsets[] = { 956 { ICE_MAC_OFOS, 0 }, 957 { ICE_IPV4_OFOS, 14 }, 958 { ICE_UDP_OF, 34 }, 959 { ICE_GTP, 42 }, 960 { ICE_IPV6_IL, 62 }, 961 { ICE_PROTOCOL_LAST, 0 }, 962 }; 963 964 static const u8 dummy_ipv4_gtpu_ipv6_packet[] = { 965 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 966 0x00, 0x00, 0x00, 0x00, 967 0x00, 0x00, 0x00, 0x00, 968 0x08, 0x00, 969 970 0x45, 0x00, 0x00, 0x58, /* ICE_IPV4_OFOS 14 */ 971 0x00, 0x00, 0x40, 0x00, 972 0x40, 0x11, 0x00, 0x00, 973 0x00, 0x00, 0x00, 0x00, 974 0x00, 0x00, 0x00, 0x00, 975 976 0x08, 0x68, 0x08, 0x68, /* ICE_UDP_OF 34 */ 977 0x00, 0x00, 0x00, 0x00, 978 979 0x34, 0xff, 0x00, 0x28, /* ICE_GTP 42 */ 980 0x00, 0x00, 0x00, 0x00, 981 0x00, 0x00, 0x00, 0x85, 982 983 0x02, 0x00, 0x00, 0x00, /* PDU Session extension header */ 984 0x00, 0x00, 0x00, 0x00, 985 986 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_IL 62 */ 987 0x00, 0x00, 0x3b, 0x00, 988 0x00, 0x00, 0x00, 0x00, 989 0x00, 0x00, 0x00, 0x00, 990 0x00, 0x00, 0x00, 0x00, 991 0x00, 0x00, 0x00, 0x00, 992 0x00, 0x00, 0x00, 0x00, 993 0x00, 0x00, 0x00, 0x00, 994 0x00, 0x00, 0x00, 0x00, 995 0x00, 0x00, 0x00, 0x00, 996 997 0x00, 0x00, 998 }; 999 1000 static const 1001 struct ice_dummy_pkt_offsets dummy_ipv6_gtpu_ipv4_packet_offsets[] = { 1002 { ICE_MAC_OFOS, 0 }, 1003 { ICE_IPV6_OFOS, 14 }, 1004 { ICE_UDP_OF, 54 }, 1005 { ICE_GTP, 62 }, 1006 { ICE_IPV4_IL, 82 }, 1007 { ICE_PROTOCOL_LAST, 0 }, 1008 }; 1009 1010 static const u8 dummy_ipv6_gtpu_ipv4_packet[] = { 1011 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1012 0x00, 0x00, 0x00, 0x00, 1013 0x00, 0x00, 0x00, 0x00, 1014 0x86, 0xdd, 1015 1016 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_OFOS 14 */ 1017 0x00, 0x58, 0x11, 0x00, /* Next header UDP*/ 1018 0x00, 0x00, 0x00, 0x00, 1019 0x00, 0x00, 0x00, 0x00, 1020 0x00, 0x00, 0x00, 0x00, 1021 0x00, 0x00, 0x00, 0x00, 1022 0x00, 0x00, 0x00, 0x00, 1023 0x00, 0x00, 0x00, 0x00, 1024 0x00, 0x00, 0x00, 0x00, 1025 0x00, 0x00, 0x00, 0x00, 1026 1027 0x08, 0x68, 0x08, 0x68, /* ICE_UDP_OF 54 */ 1028 0x00, 0x00, 0x00, 0x00, 1029 1030 0x34, 0xff, 0x00, 0x28, /* ICE_GTP 62 */ 1031 0x00, 0x00, 0x00, 0x00, 1032 0x00, 0x00, 0x00, 0x85, 1033 1034 0x02, 0x00, 0x00, 0x00, /* PDU Session extension header */ 1035 0x00, 0x00, 0x00, 0x00, 1036 1037 0x45, 0x00, 0x00, 0x14, /* ICE_IPV4_IL 82 */ 1038 0x00, 0x00, 0x40, 0x00, 1039 0x40, 0x00, 0x00, 0x00, 1040 0x00, 0x00, 0x00, 0x00, 1041 0x00, 0x00, 0x00, 0x00, 1042 1043 0x00, 0x00, 1044 }; 1045 1046 static const 1047 struct ice_dummy_pkt_offsets dummy_ipv6_gtpu_ipv6_packet_offsets[] = { 1048 { ICE_MAC_OFOS, 0 }, 1049 { ICE_IPV6_OFOS, 14 }, 1050 { ICE_UDP_OF, 54 }, 1051 { ICE_GTP, 62 }, 1052 { ICE_IPV6_IL, 82 }, 1053 { ICE_PROTOCOL_LAST, 0 }, 1054 }; 1055 1056 static const u8 dummy_ipv6_gtpu_ipv6_packet[] = { 1057 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1058 0x00, 0x00, 0x00, 0x00, 1059 0x00, 0x00, 0x00, 0x00, 1060 0x86, 0xdd, 1061 1062 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_OFOS 14 */ 1063 0x00, 0x6c, 0x11, 0x00, /* Next header UDP*/ 1064 0x00, 0x00, 0x00, 0x00, 1065 0x00, 0x00, 0x00, 0x00, 1066 0x00, 0x00, 0x00, 0x00, 1067 0x00, 0x00, 0x00, 0x00, 1068 0x00, 0x00, 0x00, 0x00, 1069 0x00, 0x00, 0x00, 0x00, 1070 0x00, 0x00, 0x00, 0x00, 1071 0x00, 0x00, 0x00, 0x00, 1072 1073 0x08, 0x68, 0x08, 0x68, /* ICE_UDP_OF 54 */ 1074 0x00, 0x00, 0x00, 0x00, 1075 1076 0x34, 0xff, 0x00, 0x28, /* ICE_GTP 62 */ 1077 0x00, 0x00, 0x00, 0x00, 1078 0x00, 0x00, 0x00, 0x85, 1079 1080 0x02, 0x00, 0x00, 0x00, /* PDU Session extension header */ 1081 0x00, 0x00, 0x00, 0x00, 1082 1083 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_OFIL 82 */ 1084 0x00, 0x00, 0x3b, 0x00, 1085 0x00, 0x00, 0x00, 0x00, 1086 0x00, 0x00, 0x00, 0x00, 1087 0x00, 0x00, 0x00, 0x00, 1088 0x00, 0x00, 0x00, 0x00, 1089 0x00, 0x00, 0x00, 0x00, 1090 0x00, 0x00, 0x00, 0x00, 1091 0x00, 0x00, 0x00, 0x00, 1092 0x00, 0x00, 0x00, 0x00, 1093 1094 0x00, 0x00, 1095 }; 1096 1097 static const struct ice_dummy_pkt_offsets dummy_udp_gtp_packet_offsets[] = { 1098 { ICE_MAC_OFOS, 0 }, 1099 { ICE_IPV4_OFOS, 14 }, 1100 { ICE_UDP_OF, 34 }, 1101 { ICE_GTP, 42 }, 1102 { ICE_PROTOCOL_LAST, 0 }, 1103 }; 1104 1105 static const u8 dummy_udp_gtp_packet[] = { 1106 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1107 0x00, 0x00, 0x00, 0x00, 1108 0x00, 0x00, 0x00, 0x00, 1109 0x08, 0x00, 1110 1111 0x45, 0x00, 0x00, 0x30, /* ICE_IPV4_OFOS 14 */ 1112 0x00, 0x00, 0x00, 0x00, 1113 0x00, 0x11, 0x00, 0x00, 1114 0x00, 0x00, 0x00, 0x00, 1115 0x00, 0x00, 0x00, 0x00, 1116 1117 0x00, 0x00, 0x08, 0x68, /* ICE_UDP_OF 34 */ 1118 0x00, 0x1c, 0x00, 0x00, 1119 1120 0x34, 0xff, 0x00, 0x0c, /* ICE_GTP 42 */ 1121 0x00, 0x00, 0x00, 0x00, 1122 0x00, 0x00, 0x00, 0x85, 1123 1124 0x02, 0x00, 0x00, 0x00, /* PDU Session extension header */ 1125 0x00, 0x00, 0x00, 0x00, 1126 }; 1127 1128 static const struct ice_dummy_pkt_offsets dummy_ipv4_gtp_no_pay_packet_offsets[] = { 1129 { ICE_MAC_OFOS, 0 }, 1130 { ICE_IPV4_OFOS, 14 }, 1131 { ICE_UDP_OF, 34 }, 1132 { ICE_GTP_NO_PAY, 42 }, 1133 { ICE_PROTOCOL_LAST, 0 }, 1134 }; 1135 1136 static const 1137 struct ice_dummy_pkt_offsets dummy_ipv6_gtp_no_pay_packet_offsets[] = { 1138 { ICE_MAC_OFOS, 0 }, 1139 { ICE_IPV6_OFOS, 14 }, 1140 { ICE_UDP_OF, 54 }, 1141 { ICE_GTP_NO_PAY, 62 }, 1142 { ICE_PROTOCOL_LAST, 0 }, 1143 }; 1144 1145 static const struct ice_dummy_pkt_offsets dummy_pppoe_packet_offsets[] = { 1146 { ICE_MAC_OFOS, 0 }, 1147 { ICE_ETYPE_OL, 12 }, 1148 { ICE_VLAN_OFOS, 14}, 1149 { ICE_PPPOE, 18 }, 1150 { ICE_PROTOCOL_LAST, 0 }, 1151 }; 1152 1153 static const struct ice_dummy_pkt_offsets dummy_pppoe_packet_ipv4_offsets[] = { 1154 { ICE_MAC_OFOS, 0 }, 1155 { ICE_ETYPE_OL, 12 }, 1156 { ICE_VLAN_OFOS, 14}, 1157 { ICE_PPPOE, 18 }, 1158 { ICE_IPV4_OFOS, 26 }, 1159 { ICE_PROTOCOL_LAST, 0 }, 1160 }; 1161 1162 static const u8 dummy_pppoe_ipv4_packet[] = { 1163 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1164 0x00, 0x00, 0x00, 0x00, 1165 0x00, 0x00, 0x00, 0x00, 1166 1167 0x81, 0x00, /* ICE_ETYPE_OL 12 */ 1168 1169 0x00, 0x00, 0x88, 0x64, /* ICE_VLAN_OFOS 14 */ 1170 1171 0x11, 0x00, 0x00, 0x00, /* ICE_PPPOE 18 */ 1172 0x00, 0x16, 1173 1174 0x00, 0x21, /* PPP Link Layer 24 */ 1175 1176 0x45, 0x00, 0x00, 0x14, /* ICE_IPV4_IL 26 */ 1177 0x00, 0x00, 0x00, 0x00, 1178 0x00, 0x00, 0x00, 0x00, 1179 0x00, 0x00, 0x00, 0x00, 1180 0x00, 0x00, 0x00, 0x00, 1181 1182 0x00, 0x00, /* 2 bytes for 4 bytes alignment */ 1183 }; 1184 1185 static const 1186 struct ice_dummy_pkt_offsets dummy_pppoe_ipv4_tcp_packet_offsets[] = { 1187 { ICE_MAC_OFOS, 0 }, 1188 { ICE_ETYPE_OL, 12 }, 1189 { ICE_VLAN_OFOS, 14}, 1190 { ICE_PPPOE, 18 }, 1191 { ICE_IPV4_OFOS, 26 }, 1192 { ICE_TCP_IL, 46 }, 1193 { ICE_PROTOCOL_LAST, 0 }, 1194 }; 1195 1196 static const u8 dummy_pppoe_ipv4_tcp_packet[] = { 1197 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1198 0x00, 0x00, 0x00, 0x00, 1199 0x00, 0x00, 0x00, 0x00, 1200 1201 0x81, 0x00, /* ICE_ETYPE_OL 12 */ 1202 1203 0x00, 0x00, 0x88, 0x64, /* ICE_VLAN_OFOS 14 */ 1204 1205 0x11, 0x00, 0x00, 0x00, /* ICE_PPPOE 18 */ 1206 0x00, 0x16, 1207 1208 0x00, 0x21, /* PPP Link Layer 24 */ 1209 1210 0x45, 0x00, 0x00, 0x28, /* ICE_IPV4_OFOS 26 */ 1211 0x00, 0x01, 0x00, 0x00, 1212 0x00, 0x06, 0x00, 0x00, 1213 0x00, 0x00, 0x00, 0x00, 1214 0x00, 0x00, 0x00, 0x00, 1215 1216 0x00, 0x00, 0x00, 0x00, /* ICE_TCP_IL 46 */ 1217 0x00, 0x00, 0x00, 0x00, 1218 0x00, 0x00, 0x00, 0x00, 1219 0x50, 0x00, 0x00, 0x00, 1220 0x00, 0x00, 0x00, 0x00, 1221 1222 0x00, 0x00, /* 2 bytes for 4 bytes alignment */ 1223 }; 1224 1225 static const 1226 struct ice_dummy_pkt_offsets dummy_pppoe_ipv4_udp_packet_offsets[] = { 1227 { ICE_MAC_OFOS, 0 }, 1228 { ICE_ETYPE_OL, 12 }, 1229 { ICE_VLAN_OFOS, 14}, 1230 { ICE_PPPOE, 18 }, 1231 { ICE_IPV4_OFOS, 26 }, 1232 { ICE_UDP_ILOS, 46 }, 1233 { ICE_PROTOCOL_LAST, 0 }, 1234 }; 1235 1236 static const u8 dummy_pppoe_ipv4_udp_packet[] = { 1237 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1238 0x00, 0x00, 0x00, 0x00, 1239 0x00, 0x00, 0x00, 0x00, 1240 1241 0x81, 0x00, /* ICE_ETYPE_OL 12 */ 1242 1243 0x00, 0x00, 0x88, 0x64, /* ICE_VLAN_OFOS 14 */ 1244 1245 0x11, 0x00, 0x00, 0x00, /* ICE_PPPOE 18 */ 1246 0x00, 0x16, 1247 1248 0x00, 0x21, /* PPP Link Layer 24 */ 1249 1250 0x45, 0x00, 0x00, 0x1c, /* ICE_IPV4_OFOS 26 */ 1251 0x00, 0x01, 0x00, 0x00, 1252 0x00, 0x11, 0x00, 0x00, 1253 0x00, 0x00, 0x00, 0x00, 1254 0x00, 0x00, 0x00, 0x00, 1255 1256 0x00, 0x00, 0x00, 0x00, /* ICE_UDP_ILOS 46 */ 1257 0x00, 0x08, 0x00, 0x00, 1258 1259 0x00, 0x00, /* 2 bytes for 4 bytes alignment */ 1260 }; 1261 1262 static const struct ice_dummy_pkt_offsets dummy_pppoe_packet_ipv6_offsets[] = { 1263 { ICE_MAC_OFOS, 0 }, 1264 { ICE_ETYPE_OL, 12 }, 1265 { ICE_VLAN_OFOS, 14}, 1266 { ICE_PPPOE, 18 }, 1267 { ICE_IPV6_OFOS, 26 }, 1268 { ICE_PROTOCOL_LAST, 0 }, 1269 }; 1270 1271 static const u8 dummy_pppoe_ipv6_packet[] = { 1272 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1273 0x00, 0x00, 0x00, 0x00, 1274 0x00, 0x00, 0x00, 0x00, 1275 1276 0x81, 0x00, /* ICE_ETYPE_OL 12 */ 1277 1278 0x00, 0x00, 0x88, 0x64, /* ICE_VLAN_OFOS 14 */ 1279 1280 0x11, 0x00, 0x00, 0x00, /* ICE_PPPOE 18 */ 1281 0x00, 0x2a, 1282 1283 0x00, 0x57, /* PPP Link Layer 24 */ 1284 1285 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_OFOS 26 */ 1286 0x00, 0x00, 0x3b, 0x00, 1287 0x00, 0x00, 0x00, 0x00, 1288 0x00, 0x00, 0x00, 0x00, 1289 0x00, 0x00, 0x00, 0x00, 1290 0x00, 0x00, 0x00, 0x00, 1291 0x00, 0x00, 0x00, 0x00, 1292 0x00, 0x00, 0x00, 0x00, 1293 0x00, 0x00, 0x00, 0x00, 1294 0x00, 0x00, 0x00, 0x00, 1295 1296 0x00, 0x00, /* 2 bytes for 4 bytes alignment */ 1297 }; 1298 1299 static const 1300 struct ice_dummy_pkt_offsets dummy_pppoe_packet_ipv6_tcp_offsets[] = { 1301 { ICE_MAC_OFOS, 0 }, 1302 { ICE_ETYPE_OL, 12 }, 1303 { ICE_VLAN_OFOS, 14}, 1304 { ICE_PPPOE, 18 }, 1305 { ICE_IPV6_OFOS, 26 }, 1306 { ICE_TCP_IL, 66 }, 1307 { ICE_PROTOCOL_LAST, 0 }, 1308 }; 1309 1310 static const u8 dummy_pppoe_ipv6_tcp_packet[] = { 1311 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1312 0x00, 0x00, 0x00, 0x00, 1313 0x00, 0x00, 0x00, 0x00, 1314 1315 0x81, 0x00, /* ICE_ETYPE_OL 12 */ 1316 1317 0x00, 0x00, 0x88, 0x64, /* ICE_VLAN_OFOS 14 */ 1318 1319 0x11, 0x00, 0x00, 0x00, /* ICE_PPPOE 18 */ 1320 0x00, 0x2a, 1321 1322 0x00, 0x57, /* PPP Link Layer 24 */ 1323 1324 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_OFOS 26 */ 1325 0x00, 0x14, 0x06, 0x00, /* Next header is TCP */ 1326 0x00, 0x00, 0x00, 0x00, 1327 0x00, 0x00, 0x00, 0x00, 1328 0x00, 0x00, 0x00, 0x00, 1329 0x00, 0x00, 0x00, 0x00, 1330 0x00, 0x00, 0x00, 0x00, 1331 0x00, 0x00, 0x00, 0x00, 1332 0x00, 0x00, 0x00, 0x00, 1333 0x00, 0x00, 0x00, 0x00, 1334 1335 0x00, 0x00, 0x00, 0x00, /* ICE_TCP_IL 66 */ 1336 0x00, 0x00, 0x00, 0x00, 1337 0x00, 0x00, 0x00, 0x00, 1338 0x50, 0x00, 0x00, 0x00, 1339 0x00, 0x00, 0x00, 0x00, 1340 1341 0x00, 0x00, /* 2 bytes for 4 bytes alignment */ 1342 }; 1343 1344 static const 1345 struct ice_dummy_pkt_offsets dummy_pppoe_packet_ipv6_udp_offsets[] = { 1346 { ICE_MAC_OFOS, 0 }, 1347 { ICE_ETYPE_OL, 12 }, 1348 { ICE_VLAN_OFOS, 14}, 1349 { ICE_PPPOE, 18 }, 1350 { ICE_IPV6_OFOS, 26 }, 1351 { ICE_UDP_ILOS, 66 }, 1352 { ICE_PROTOCOL_LAST, 0 }, 1353 }; 1354 1355 static const u8 dummy_pppoe_ipv6_udp_packet[] = { 1356 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1357 0x00, 0x00, 0x00, 0x00, 1358 0x00, 0x00, 0x00, 0x00, 1359 1360 0x81, 0x00, /* ICE_ETYPE_OL 12 */ 1361 1362 0x00, 0x00, 0x88, 0x64, /* ICE_VLAN_OFOS 14 */ 1363 1364 0x11, 0x00, 0x00, 0x00, /* ICE_PPPOE 18 */ 1365 0x00, 0x2a, 1366 1367 0x00, 0x57, /* PPP Link Layer 24 */ 1368 1369 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_OFOS 26 */ 1370 0x00, 0x08, 0x11, 0x00, /* Next header UDP*/ 1371 0x00, 0x00, 0x00, 0x00, 1372 0x00, 0x00, 0x00, 0x00, 1373 0x00, 0x00, 0x00, 0x00, 1374 0x00, 0x00, 0x00, 0x00, 1375 0x00, 0x00, 0x00, 0x00, 1376 0x00, 0x00, 0x00, 0x00, 1377 0x00, 0x00, 0x00, 0x00, 1378 0x00, 0x00, 0x00, 0x00, 1379 1380 0x00, 0x00, 0x00, 0x00, /* ICE_UDP_ILOS 66 */ 1381 0x00, 0x08, 0x00, 0x00, 1382 1383 0x00, 0x00, /* 2 bytes for 4 bytes alignment */ 1384 }; 1385 1386 static const struct ice_dummy_pkt_offsets dummy_ipv4_esp_packet_offsets[] = { 1387 { ICE_MAC_OFOS, 0 }, 1388 { ICE_IPV4_OFOS, 14 }, 1389 { ICE_ESP, 34 }, 1390 { ICE_PROTOCOL_LAST, 0 }, 1391 }; 1392 1393 static const u8 dummy_ipv4_esp_pkt[] = { 1394 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1395 0x00, 0x00, 0x00, 0x00, 1396 0x00, 0x00, 0x00, 0x00, 1397 0x08, 0x00, 1398 1399 0x45, 0x00, 0x00, 0x1c, /* ICE_IPV4_IL 14 */ 1400 0x00, 0x00, 0x40, 0x00, 1401 0x40, 0x32, 0x00, 0x00, 1402 0x00, 0x00, 0x00, 0x00, 1403 0x00, 0x00, 0x00, 0x00, 1404 1405 0x00, 0x00, 0x00, 0x00, /* ICE_ESP 34 */ 1406 0x00, 0x00, 0x00, 0x00, 1407 0x00, 0x00, /* 2 bytes for 4 bytes alignment */ 1408 }; 1409 1410 static const struct ice_dummy_pkt_offsets dummy_ipv6_esp_packet_offsets[] = { 1411 { ICE_MAC_OFOS, 0 }, 1412 { ICE_IPV6_OFOS, 14 }, 1413 { ICE_ESP, 54 }, 1414 { ICE_PROTOCOL_LAST, 0 }, 1415 }; 1416 1417 static const u8 dummy_ipv6_esp_pkt[] = { 1418 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1419 0x00, 0x00, 0x00, 0x00, 1420 0x00, 0x00, 0x00, 0x00, 1421 0x86, 0xDD, 1422 1423 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_OFOS 14 */ 1424 0x00, 0x08, 0x32, 0x00, /* Next header ESP */ 1425 0x00, 0x00, 0x00, 0x00, 1426 0x00, 0x00, 0x00, 0x00, 1427 0x00, 0x00, 0x00, 0x00, 1428 0x00, 0x00, 0x00, 0x00, 1429 0x00, 0x00, 0x00, 0x00, 1430 0x00, 0x00, 0x00, 0x00, 1431 0x00, 0x00, 0x00, 0x00, 1432 0x00, 0x00, 0x00, 0x00, 1433 1434 0x00, 0x00, 0x00, 0x00, /* ICE_ESP 54 */ 1435 0x00, 0x00, 0x00, 0x00, 1436 0x00, 0x00, /* 2 bytes for 4 bytes alignment */ 1437 }; 1438 1439 static const struct ice_dummy_pkt_offsets dummy_ipv4_ah_packet_offsets[] = { 1440 { ICE_MAC_OFOS, 0 }, 1441 { ICE_IPV4_OFOS, 14 }, 1442 { ICE_AH, 34 }, 1443 { ICE_PROTOCOL_LAST, 0 }, 1444 }; 1445 1446 static const u8 dummy_ipv4_ah_pkt[] = { 1447 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1448 0x00, 0x00, 0x00, 0x00, 1449 0x00, 0x00, 0x00, 0x00, 1450 0x08, 0x00, 1451 1452 0x45, 0x00, 0x00, 0x20, /* ICE_IPV4_IL 14 */ 1453 0x00, 0x00, 0x40, 0x00, 1454 0x40, 0x33, 0x00, 0x00, 1455 0x00, 0x00, 0x00, 0x00, 1456 0x00, 0x00, 0x00, 0x00, 1457 1458 0x00, 0x00, 0x00, 0x00, /* ICE_AH 34 */ 1459 0x00, 0x00, 0x00, 0x00, 1460 0x00, 0x00, 0x00, 0x00, 1461 0x00, 0x00, /* 2 bytes for 4 bytes alignment */ 1462 }; 1463 1464 static const struct ice_dummy_pkt_offsets dummy_ipv6_ah_packet_offsets[] = { 1465 { ICE_MAC_OFOS, 0 }, 1466 { ICE_IPV6_OFOS, 14 }, 1467 { ICE_AH, 54 }, 1468 { ICE_PROTOCOL_LAST, 0 }, 1469 }; 1470 1471 static const u8 dummy_ipv6_ah_pkt[] = { 1472 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1473 0x00, 0x00, 0x00, 0x00, 1474 0x00, 0x00, 0x00, 0x00, 1475 0x86, 0xDD, 1476 1477 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_OFOS 14 */ 1478 0x00, 0x0c, 0x33, 0x00, /* Next header AH */ 1479 0x00, 0x00, 0x00, 0x00, 1480 0x00, 0x00, 0x00, 0x00, 1481 0x00, 0x00, 0x00, 0x00, 1482 0x00, 0x00, 0x00, 0x00, 1483 0x00, 0x00, 0x00, 0x00, 1484 0x00, 0x00, 0x00, 0x00, 1485 0x00, 0x00, 0x00, 0x00, 1486 0x00, 0x00, 0x00, 0x00, 1487 1488 0x00, 0x00, 0x00, 0x00, /* ICE_AH 54 */ 1489 0x00, 0x00, 0x00, 0x00, 1490 0x00, 0x00, 0x00, 0x00, 1491 0x00, 0x00, /* 2 bytes for 4 bytes alignment */ 1492 }; 1493 1494 static const struct ice_dummy_pkt_offsets dummy_ipv4_nat_packet_offsets[] = { 1495 { ICE_MAC_OFOS, 0 }, 1496 { ICE_IPV4_OFOS, 14 }, 1497 { ICE_UDP_ILOS, 34 }, 1498 { ICE_NAT_T, 42 }, 1499 { ICE_PROTOCOL_LAST, 0 }, 1500 }; 1501 1502 static const u8 dummy_ipv4_nat_pkt[] = { 1503 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1504 0x00, 0x00, 0x00, 0x00, 1505 0x00, 0x00, 0x00, 0x00, 1506 0x08, 0x00, 1507 1508 0x45, 0x00, 0x00, 0x24, /* ICE_IPV4_IL 14 */ 1509 0x00, 0x00, 0x40, 0x00, 1510 0x40, 0x11, 0x00, 0x00, 1511 0x00, 0x00, 0x00, 0x00, 1512 0x00, 0x00, 0x00, 0x00, 1513 1514 0x00, 0x00, 0x11, 0x94, /* ICE_NAT_T 34 */ 1515 0x00, 0x00, 0x00, 0x00, 1516 1517 0x00, 0x00, 0x00, 0x00, 1518 0x00, 0x00, 0x00, 0x00, 1519 0x00, 0x00, /* 2 bytes for 4 bytes alignment */ 1520 }; 1521 1522 static const struct ice_dummy_pkt_offsets dummy_ipv6_nat_packet_offsets[] = { 1523 { ICE_MAC_OFOS, 0 }, 1524 { ICE_IPV6_OFOS, 14 }, 1525 { ICE_UDP_ILOS, 54 }, 1526 { ICE_NAT_T, 62 }, 1527 { ICE_PROTOCOL_LAST, 0 }, 1528 }; 1529 1530 static const u8 dummy_ipv6_nat_pkt[] = { 1531 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1532 0x00, 0x00, 0x00, 0x00, 1533 0x00, 0x00, 0x00, 0x00, 1534 0x86, 0xDD, 1535 1536 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_OFOS 14 */ 1537 0x00, 0x10, 0x11, 0x00, /* Next header NAT_T */ 1538 0x00, 0x00, 0x00, 0x00, 1539 0x00, 0x00, 0x00, 0x00, 1540 0x00, 0x00, 0x00, 0x00, 1541 0x00, 0x00, 0x00, 0x00, 1542 0x00, 0x00, 0x00, 0x00, 1543 0x00, 0x00, 0x00, 0x00, 1544 0x00, 0x00, 0x00, 0x00, 1545 0x00, 0x00, 0x00, 0x00, 1546 1547 0x00, 0x00, 0x11, 0x94, /* ICE_NAT_T 54 */ 1548 0x00, 0x00, 0x00, 0x00, 1549 1550 0x00, 0x00, 0x00, 0x00, 1551 0x00, 0x00, 0x00, 0x00, 1552 0x00, 0x00, /* 2 bytes for 4 bytes alignment */ 1553 1554 }; 1555 1556 static const struct ice_dummy_pkt_offsets dummy_ipv4_l2tpv3_packet_offsets[] = { 1557 { ICE_MAC_OFOS, 0 }, 1558 { ICE_IPV4_OFOS, 14 }, 1559 { ICE_L2TPV3, 34 }, 1560 { ICE_PROTOCOL_LAST, 0 }, 1561 }; 1562 1563 static const u8 dummy_ipv4_l2tpv3_pkt[] = { 1564 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1565 0x00, 0x00, 0x00, 0x00, 1566 0x00, 0x00, 0x00, 0x00, 1567 0x08, 0x00, 1568 1569 0x45, 0x00, 0x00, 0x20, /* ICE_IPV4_IL 14 */ 1570 0x00, 0x00, 0x40, 0x00, 1571 0x40, 0x73, 0x00, 0x00, 1572 0x00, 0x00, 0x00, 0x00, 1573 0x00, 0x00, 0x00, 0x00, 1574 1575 0x00, 0x00, 0x00, 0x00, /* ICE_L2TPV3 34 */ 1576 0x00, 0x00, 0x00, 0x00, 1577 0x00, 0x00, 0x00, 0x00, 1578 0x00, 0x00, /* 2 bytes for 4 bytes alignment */ 1579 }; 1580 1581 static const struct ice_dummy_pkt_offsets dummy_ipv6_l2tpv3_packet_offsets[] = { 1582 { ICE_MAC_OFOS, 0 }, 1583 { ICE_IPV6_OFOS, 14 }, 1584 { ICE_L2TPV3, 54 }, 1585 { ICE_PROTOCOL_LAST, 0 }, 1586 }; 1587 1588 static const u8 dummy_ipv6_l2tpv3_pkt[] = { 1589 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1590 0x00, 0x00, 0x00, 0x00, 1591 0x00, 0x00, 0x00, 0x00, 1592 0x86, 0xDD, 1593 1594 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_IL 14 */ 1595 0x00, 0x0c, 0x73, 0x40, 1596 0x00, 0x00, 0x00, 0x00, 1597 0x00, 0x00, 0x00, 0x00, 1598 0x00, 0x00, 0x00, 0x00, 1599 0x00, 0x00, 0x00, 0x00, 1600 0x00, 0x00, 0x00, 0x00, 1601 0x00, 0x00, 0x00, 0x00, 1602 0x00, 0x00, 0x00, 0x00, 1603 0x00, 0x00, 0x00, 0x00, 1604 1605 0x00, 0x00, 0x00, 0x00, /* ICE_L2TPV3 54 */ 1606 0x00, 0x00, 0x00, 0x00, 1607 0x00, 0x00, 0x00, 0x00, 1608 0x00, 0x00, /* 2 bytes for 4 bytes alignment */ 1609 }; 1610 1611 static const struct ice_dummy_pkt_offsets dummy_qinq_ipv4_packet_offsets[] = { 1612 { ICE_MAC_OFOS, 0 }, 1613 { ICE_ETYPE_OL, 12 }, 1614 { ICE_VLAN_EX, 14 }, 1615 { ICE_VLAN_OFOS, 18 }, 1616 { ICE_IPV4_OFOS, 22 }, 1617 { ICE_PROTOCOL_LAST, 0 }, 1618 }; 1619 1620 static const u8 dummy_qinq_ipv4_pkt[] = { 1621 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1622 0x00, 0x00, 0x00, 0x00, 1623 0x00, 0x00, 0x00, 0x00, 1624 1625 0x91, 0x00, /* ICE_ETYPE_OL 12 */ 1626 1627 0x00, 0x00, 0x81, 0x00, /* ICE_VLAN_EX 14 */ 1628 0x00, 0x00, 0x08, 0x00, /* ICE_VLAN_OFOS 18 */ 1629 1630 0x45, 0x00, 0x00, 0x1c, /* ICE_IPV4_OFOS 22 */ 1631 0x00, 0x01, 0x00, 0x00, 1632 0x00, 0x11, 0x00, 0x00, 1633 0x00, 0x00, 0x00, 0x00, 1634 0x00, 0x00, 0x00, 0x00, 1635 1636 0x00, 0x00, 0x00, 0x00, /* ICE_UDP_ILOS 42 */ 1637 0x00, 0x08, 0x00, 0x00, 1638 1639 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 1640 }; 1641 1642 static const struct ice_dummy_pkt_offsets dummy_qinq_ipv6_packet_offsets[] = { 1643 { ICE_MAC_OFOS, 0 }, 1644 { ICE_ETYPE_OL, 12 }, 1645 { ICE_VLAN_EX, 14 }, 1646 { ICE_VLAN_OFOS, 18 }, 1647 { ICE_IPV6_OFOS, 22 }, 1648 { ICE_PROTOCOL_LAST, 0 }, 1649 }; 1650 1651 static const u8 dummy_qinq_ipv6_pkt[] = { 1652 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1653 0x00, 0x00, 0x00, 0x00, 1654 0x00, 0x00, 0x00, 0x00, 1655 1656 0x91, 0x00, /* ICE_ETYPE_OL 12 */ 1657 1658 0x00, 0x00, 0x81, 0x00, /* ICE_VLAN_EX 14 */ 1659 0x00, 0x00, 0x86, 0xDD, /* ICE_VLAN_OFOS 18 */ 1660 1661 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_OFOS 22 */ 1662 0x00, 0x10, 0x11, 0x00, /* Next header UDP */ 1663 0x00, 0x00, 0x00, 0x00, 1664 0x00, 0x00, 0x00, 0x00, 1665 0x00, 0x00, 0x00, 0x00, 1666 0x00, 0x00, 0x00, 0x00, 1667 0x00, 0x00, 0x00, 0x00, 1668 0x00, 0x00, 0x00, 0x00, 1669 0x00, 0x00, 0x00, 0x00, 1670 0x00, 0x00, 0x00, 0x00, 1671 1672 0x00, 0x00, 0x00, 0x00, /* ICE_UDP_ILOS 62 */ 1673 0x00, 0x10, 0x00, 0x00, 1674 1675 0x00, 0x00, 0x00, 0x00, /* needed for ESP packets */ 1676 0x00, 0x00, 0x00, 0x00, 1677 1678 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 1679 }; 1680 1681 static const struct ice_dummy_pkt_offsets dummy_qinq_pppoe_packet_offsets[] = { 1682 { ICE_MAC_OFOS, 0 }, 1683 { ICE_ETYPE_OL, 12 }, 1684 { ICE_VLAN_EX, 14 }, 1685 { ICE_VLAN_OFOS, 18 }, 1686 { ICE_PPPOE, 22 }, 1687 { ICE_PROTOCOL_LAST, 0 }, 1688 }; 1689 1690 static const 1691 struct ice_dummy_pkt_offsets dummy_qinq_pppoe_ipv4_packet_offsets[] = { 1692 { ICE_MAC_OFOS, 0 }, 1693 { ICE_ETYPE_OL, 12 }, 1694 { ICE_VLAN_EX, 14 }, 1695 { ICE_VLAN_OFOS, 18 }, 1696 { ICE_PPPOE, 22 }, 1697 { ICE_IPV4_OFOS, 30 }, 1698 { ICE_PROTOCOL_LAST, 0 }, 1699 }; 1700 1701 static const u8 dummy_qinq_pppoe_ipv4_pkt[] = { 1702 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1703 0x00, 0x00, 0x00, 0x00, 1704 0x00, 0x00, 0x00, 0x00, 1705 1706 0x91, 0x00, /* ICE_ETYPE_OL 12 */ 1707 1708 0x00, 0x00, 0x81, 0x00, /* ICE_VLAN_EX 14 */ 1709 0x00, 0x00, 0x88, 0x64, /* ICE_VLAN_OFOS 18 */ 1710 1711 0x11, 0x00, 0x00, 0x00, /* ICE_PPPOE 22 */ 1712 0x00, 0x16, 1713 1714 0x00, 0x21, /* PPP Link Layer 28 */ 1715 1716 0x45, 0x00, 0x00, 0x14, /* ICE_IPV4_IL 30 */ 1717 0x00, 0x00, 0x00, 0x00, 1718 0x00, 0x00, 0x00, 0x00, 1719 0x00, 0x00, 0x00, 0x00, 1720 0x00, 0x00, 0x00, 0x00, 1721 1722 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 1723 }; 1724 1725 static const 1726 struct ice_dummy_pkt_offsets dummy_qinq_pppoe_packet_ipv6_offsets[] = { 1727 { ICE_MAC_OFOS, 0 }, 1728 { ICE_ETYPE_OL, 12 }, 1729 { ICE_VLAN_EX, 14}, 1730 { ICE_VLAN_OFOS, 18 }, 1731 { ICE_PPPOE, 22 }, 1732 { ICE_IPV6_OFOS, 30 }, 1733 { ICE_PROTOCOL_LAST, 0 }, 1734 }; 1735 1736 static const u8 dummy_qinq_pppoe_ipv6_packet[] = { 1737 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1738 0x00, 0x00, 0x00, 0x00, 1739 0x00, 0x00, 0x00, 0x00, 1740 1741 0x91, 0x00, /* ICE_ETYPE_OL 12 */ 1742 1743 0x00, 0x00, 0x81, 0x00, /* ICE_VLAN_EX 14 */ 1744 0x00, 0x00, 0x88, 0x64, /* ICE_VLAN_OFOS 18 */ 1745 1746 0x11, 0x00, 0x00, 0x00, /* ICE_PPPOE 22 */ 1747 0x00, 0x2a, 1748 1749 0x00, 0x57, /* PPP Link Layer 28*/ 1750 1751 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_OFOS 30 */ 1752 0x00, 0x00, 0x3b, 0x00, 1753 0x00, 0x00, 0x00, 0x00, 1754 0x00, 0x00, 0x00, 0x00, 1755 0x00, 0x00, 0x00, 0x00, 1756 0x00, 0x00, 0x00, 0x00, 1757 0x00, 0x00, 0x00, 0x00, 1758 0x00, 0x00, 0x00, 0x00, 1759 0x00, 0x00, 0x00, 0x00, 1760 0x00, 0x00, 0x00, 0x00, 1761 1762 0x00, 0x00, /* 2 bytes for 4 bytes alignment */ 1763 }; 1764 1765 /* this is a recipe to profile association bitmap */ 1766 static ice_declare_bitmap(recipe_to_profile[ICE_MAX_NUM_RECIPES], 1767 ICE_MAX_NUM_PROFILES); 1768 1769 /* this is a profile to recipe association bitmap */ 1770 static ice_declare_bitmap(profile_to_recipe[ICE_MAX_NUM_PROFILES], 1771 ICE_MAX_NUM_RECIPES); 1772 1773 static void ice_get_recp_to_prof_map(struct ice_hw *hw); 1774 1775 /** 1776 * ice_collect_result_idx - copy result index values 1777 * @buf: buffer that contains the result index 1778 * @recp: the recipe struct to copy data into 1779 */ 1780 static void ice_collect_result_idx(struct ice_aqc_recipe_data_elem *buf, 1781 struct ice_sw_recipe *recp) 1782 { 1783 if (buf->content.result_indx & ICE_AQ_RECIPE_RESULT_EN) 1784 ice_set_bit(buf->content.result_indx & 1785 ~ICE_AQ_RECIPE_RESULT_EN, recp->res_idxs); 1786 } 1787 1788 /** 1789 * ice_get_tun_type_for_recipe - get tunnel type for the recipe 1790 * @rid: recipe ID that we are populating 1791 */ 1792 static enum ice_sw_tunnel_type ice_get_tun_type_for_recipe(u8 rid, bool vlan) 1793 { 1794 u8 vxlan_profile[12] = {10, 11, 12, 16, 17, 18, 22, 23, 24, 25, 26, 27}; 1795 u8 gre_profile[12] = {13, 14, 15, 19, 20, 21, 28, 29, 30, 31, 32, 33}; 1796 u8 pppoe_profile[7] = {34, 35, 36, 37, 38, 39, 40}; 1797 u8 non_tun_profile[6] = {4, 5, 6, 7, 8, 9}; 1798 enum ice_sw_tunnel_type tun_type; 1799 u16 i, j, profile_num = 0; 1800 bool non_tun_valid = false; 1801 bool pppoe_valid = false; 1802 bool vxlan_valid = false; 1803 bool gre_valid = false; 1804 bool gtp_valid = false; 1805 bool flag_valid = false; 1806 1807 for (j = 0; j < ICE_MAX_NUM_PROFILES; j++) { 1808 if (!ice_is_bit_set(recipe_to_profile[rid], j)) 1809 continue; 1810 else 1811 profile_num++; 1812 1813 for (i = 0; i < 12; i++) { 1814 if (gre_profile[i] == j) 1815 gre_valid = true; 1816 } 1817 1818 for (i = 0; i < 12; i++) { 1819 if (vxlan_profile[i] == j) 1820 vxlan_valid = true; 1821 } 1822 1823 for (i = 0; i < 7; i++) { 1824 if (pppoe_profile[i] == j) 1825 pppoe_valid = true; 1826 } 1827 1828 for (i = 0; i < 6; i++) { 1829 if (non_tun_profile[i] == j) 1830 non_tun_valid = true; 1831 } 1832 1833 if (j >= ICE_PROFID_IPV4_GTPU_EH_IPV4_OTHER && 1834 j <= ICE_PROFID_IPV6_GTPU_IPV6_TCP) 1835 gtp_valid = true; 1836 1837 if ((j >= ICE_PROFID_IPV4_ESP && 1838 j <= ICE_PROFID_IPV6_PFCP_SESSION) || 1839 (j >= ICE_PROFID_IPV4_GTPC_TEID && 1840 j <= ICE_PROFID_IPV6_GTPU_TEID)) 1841 flag_valid = true; 1842 } 1843 1844 if (!non_tun_valid && vxlan_valid) 1845 tun_type = ICE_SW_TUN_VXLAN; 1846 else if (!non_tun_valid && gre_valid) 1847 tun_type = ICE_SW_TUN_NVGRE; 1848 else if (!non_tun_valid && pppoe_valid) 1849 tun_type = ICE_SW_TUN_PPPOE; 1850 else if (!non_tun_valid && gtp_valid) 1851 tun_type = ICE_SW_TUN_GTP; 1852 else if (non_tun_valid && 1853 (vxlan_valid || gre_valid || gtp_valid || pppoe_valid)) 1854 tun_type = ICE_SW_TUN_AND_NON_TUN; 1855 else if (non_tun_valid && !vxlan_valid && !gre_valid && !gtp_valid && 1856 !pppoe_valid) 1857 tun_type = ICE_NON_TUN; 1858 else 1859 tun_type = ICE_NON_TUN; 1860 1861 if (profile_num > 1 && tun_type == ICE_SW_TUN_PPPOE) { 1862 i = ice_is_bit_set(recipe_to_profile[rid], 1863 ICE_PROFID_PPPOE_IPV4_OTHER); 1864 j = ice_is_bit_set(recipe_to_profile[rid], 1865 ICE_PROFID_PPPOE_IPV6_OTHER); 1866 if (i && !j) 1867 tun_type = ICE_SW_TUN_PPPOE_IPV4; 1868 else if (!i && j) 1869 tun_type = ICE_SW_TUN_PPPOE_IPV6; 1870 } 1871 1872 if (tun_type == ICE_SW_TUN_GTP) { 1873 if (ice_is_bit_set(recipe_to_profile[rid], 1874 ICE_PROFID_IPV4_GTPU_IPV4_OTHER)) 1875 tun_type = ICE_SW_TUN_IPV4_GTPU_IPV4; 1876 else if (ice_is_bit_set(recipe_to_profile[rid], 1877 ICE_PROFID_IPV4_GTPU_IPV6_OTHER)) 1878 tun_type = ICE_SW_TUN_IPV4_GTPU_IPV6; 1879 else if (ice_is_bit_set(recipe_to_profile[rid], 1880 ICE_PROFID_IPV6_GTPU_IPV4_OTHER)) 1881 tun_type = ICE_SW_TUN_IPV6_GTPU_IPV4; 1882 else if (ice_is_bit_set(recipe_to_profile[rid], 1883 ICE_PROFID_IPV6_GTPU_IPV6_OTHER)) 1884 tun_type = ICE_SW_TUN_IPV6_GTPU_IPV6; 1885 } 1886 1887 if (profile_num == 1 && (flag_valid || non_tun_valid || pppoe_valid)) { 1888 for (j = 0; j < ICE_MAX_NUM_PROFILES; j++) { 1889 if (ice_is_bit_set(recipe_to_profile[rid], j)) { 1890 switch (j) { 1891 case ICE_PROFID_IPV4_TCP: 1892 tun_type = ICE_SW_IPV4_TCP; 1893 break; 1894 case ICE_PROFID_IPV4_UDP: 1895 tun_type = ICE_SW_IPV4_UDP; 1896 break; 1897 case ICE_PROFID_IPV6_TCP: 1898 tun_type = ICE_SW_IPV6_TCP; 1899 break; 1900 case ICE_PROFID_IPV6_UDP: 1901 tun_type = ICE_SW_IPV6_UDP; 1902 break; 1903 case ICE_PROFID_PPPOE_PAY: 1904 tun_type = ICE_SW_TUN_PPPOE_PAY; 1905 break; 1906 case ICE_PROFID_PPPOE_IPV4_TCP: 1907 tun_type = ICE_SW_TUN_PPPOE_IPV4_TCP; 1908 break; 1909 case ICE_PROFID_PPPOE_IPV4_UDP: 1910 tun_type = ICE_SW_TUN_PPPOE_IPV4_UDP; 1911 break; 1912 case ICE_PROFID_PPPOE_IPV4_OTHER: 1913 tun_type = ICE_SW_TUN_PPPOE_IPV4; 1914 break; 1915 case ICE_PROFID_PPPOE_IPV6_TCP: 1916 tun_type = ICE_SW_TUN_PPPOE_IPV6_TCP; 1917 break; 1918 case ICE_PROFID_PPPOE_IPV6_UDP: 1919 tun_type = ICE_SW_TUN_PPPOE_IPV6_UDP; 1920 break; 1921 case ICE_PROFID_PPPOE_IPV6_OTHER: 1922 tun_type = ICE_SW_TUN_PPPOE_IPV6; 1923 break; 1924 case ICE_PROFID_IPV4_ESP: 1925 tun_type = ICE_SW_TUN_IPV4_ESP; 1926 break; 1927 case ICE_PROFID_IPV6_ESP: 1928 tun_type = ICE_SW_TUN_IPV6_ESP; 1929 break; 1930 case ICE_PROFID_IPV4_AH: 1931 tun_type = ICE_SW_TUN_IPV4_AH; 1932 break; 1933 case ICE_PROFID_IPV6_AH: 1934 tun_type = ICE_SW_TUN_IPV6_AH; 1935 break; 1936 case ICE_PROFID_IPV4_NAT_T: 1937 tun_type = ICE_SW_TUN_IPV4_NAT_T; 1938 break; 1939 case ICE_PROFID_IPV6_NAT_T: 1940 tun_type = ICE_SW_TUN_IPV6_NAT_T; 1941 break; 1942 case ICE_PROFID_IPV4_PFCP_NODE: 1943 tun_type = 1944 ICE_SW_TUN_PROFID_IPV4_PFCP_NODE; 1945 break; 1946 case ICE_PROFID_IPV6_PFCP_NODE: 1947 tun_type = 1948 ICE_SW_TUN_PROFID_IPV6_PFCP_NODE; 1949 break; 1950 case ICE_PROFID_IPV4_PFCP_SESSION: 1951 tun_type = 1952 ICE_SW_TUN_PROFID_IPV4_PFCP_SESSION; 1953 break; 1954 case ICE_PROFID_IPV6_PFCP_SESSION: 1955 tun_type = 1956 ICE_SW_TUN_PROFID_IPV6_PFCP_SESSION; 1957 break; 1958 case ICE_PROFID_MAC_IPV4_L2TPV3: 1959 tun_type = ICE_SW_TUN_IPV4_L2TPV3; 1960 break; 1961 case ICE_PROFID_MAC_IPV6_L2TPV3: 1962 tun_type = ICE_SW_TUN_IPV6_L2TPV3; 1963 break; 1964 case ICE_PROFID_IPV4_GTPU_TEID: 1965 tun_type = ICE_SW_TUN_IPV4_GTPU_NO_PAY; 1966 break; 1967 case ICE_PROFID_IPV6_GTPU_TEID: 1968 tun_type = ICE_SW_TUN_IPV6_GTPU_NO_PAY; 1969 break; 1970 default: 1971 break; 1972 } 1973 1974 return tun_type; 1975 } 1976 } 1977 } 1978 1979 if (vlan && tun_type == ICE_SW_TUN_PPPOE) 1980 tun_type = ICE_SW_TUN_PPPOE_QINQ; 1981 else if (vlan && tun_type == ICE_SW_TUN_PPPOE_IPV6) 1982 tun_type = ICE_SW_TUN_PPPOE_IPV6_QINQ; 1983 else if (vlan && tun_type == ICE_SW_TUN_PPPOE_IPV4) 1984 tun_type = ICE_SW_TUN_PPPOE_IPV4_QINQ; 1985 else if (vlan && tun_type == ICE_SW_TUN_PPPOE_PAY) 1986 tun_type = ICE_SW_TUN_PPPOE_PAY_QINQ; 1987 else if (vlan && tun_type == ICE_SW_TUN_AND_NON_TUN) 1988 tun_type = ICE_SW_TUN_AND_NON_TUN_QINQ; 1989 else if (vlan && tun_type == ICE_NON_TUN) 1990 tun_type = ICE_NON_TUN_QINQ; 1991 1992 return tun_type; 1993 } 1994 1995 /** 1996 * ice_get_recp_frm_fw - update SW bookkeeping from FW recipe entries 1997 * @hw: pointer to hardware structure 1998 * @recps: struct that we need to populate 1999 * @rid: recipe ID that we are populating 2000 * @refresh_required: true if we should get recipe to profile mapping from FW 2001 * 2002 * This function is used to populate all the necessary entries into our 2003 * bookkeeping so that we have a current list of all the recipes that are 2004 * programmed in the firmware. 2005 */ 2006 static enum ice_status 2007 ice_get_recp_frm_fw(struct ice_hw *hw, struct ice_sw_recipe *recps, u8 rid, 2008 bool *refresh_required) 2009 { 2010 ice_declare_bitmap(result_bm, ICE_MAX_FV_WORDS); 2011 struct ice_aqc_recipe_data_elem *tmp; 2012 u16 num_recps = ICE_MAX_NUM_RECIPES; 2013 struct ice_prot_lkup_ext *lkup_exts; 2014 enum ice_status status; 2015 u8 fv_word_idx = 0; 2016 bool vlan = false; 2017 u16 sub_recps; 2018 2019 ice_zero_bitmap(result_bm, ICE_MAX_FV_WORDS); 2020 2021 /* we need a buffer big enough to accommodate all the recipes */ 2022 tmp = (struct ice_aqc_recipe_data_elem *)ice_calloc(hw, 2023 ICE_MAX_NUM_RECIPES, sizeof(*tmp)); 2024 if (!tmp) 2025 return ICE_ERR_NO_MEMORY; 2026 2027 tmp[0].recipe_indx = rid; 2028 status = ice_aq_get_recipe(hw, tmp, &num_recps, rid, NULL); 2029 /* non-zero status meaning recipe doesn't exist */ 2030 if (status) 2031 goto err_unroll; 2032 2033 /* Get recipe to profile map so that we can get the fv from lkups that 2034 * we read for a recipe from FW. Since we want to minimize the number of 2035 * times we make this FW call, just make one call and cache the copy 2036 * until a new recipe is added. This operation is only required the 2037 * first time to get the changes from FW. Then to search existing 2038 * entries we don't need to update the cache again until another recipe 2039 * gets added. 2040 */ 2041 if (*refresh_required) { 2042 ice_get_recp_to_prof_map(hw); 2043 *refresh_required = false; 2044 } 2045 2046 /* Start populating all the entries for recps[rid] based on lkups from 2047 * firmware. Note that we are only creating the root recipe in our 2048 * database. 2049 */ 2050 lkup_exts = &recps[rid].lkup_exts; 2051 2052 for (sub_recps = 0; sub_recps < num_recps; sub_recps++) { 2053 struct ice_aqc_recipe_data_elem root_bufs = tmp[sub_recps]; 2054 struct ice_recp_grp_entry *rg_entry; 2055 u8 i, prof, idx, prot = 0; 2056 bool is_root; 2057 u16 off = 0; 2058 2059 rg_entry = (struct ice_recp_grp_entry *) 2060 ice_malloc(hw, sizeof(*rg_entry)); 2061 if (!rg_entry) { 2062 status = ICE_ERR_NO_MEMORY; 2063 goto err_unroll; 2064 } 2065 2066 idx = root_bufs.recipe_indx; 2067 is_root = root_bufs.content.rid & ICE_AQ_RECIPE_ID_IS_ROOT; 2068 2069 /* Mark all result indices in this chain */ 2070 if (root_bufs.content.result_indx & ICE_AQ_RECIPE_RESULT_EN) 2071 ice_set_bit(root_bufs.content.result_indx & 2072 ~ICE_AQ_RECIPE_RESULT_EN, result_bm); 2073 2074 /* get the first profile that is associated with rid */ 2075 prof = ice_find_first_bit(recipe_to_profile[idx], 2076 ICE_MAX_NUM_PROFILES); 2077 for (i = 0; i < ICE_NUM_WORDS_RECIPE; i++) { 2078 u8 lkup_indx = root_bufs.content.lkup_indx[i + 1]; 2079 2080 rg_entry->fv_idx[i] = lkup_indx; 2081 rg_entry->fv_mask[i] = 2082 LE16_TO_CPU(root_bufs.content.mask[i + 1]); 2083 2084 /* If the recipe is a chained recipe then all its 2085 * child recipe's result will have a result index. 2086 * To fill fv_words we should not use those result 2087 * index, we only need the protocol ids and offsets. 2088 * We will skip all the fv_idx which stores result 2089 * index in them. We also need to skip any fv_idx which 2090 * has ICE_AQ_RECIPE_LKUP_IGNORE or 0 since it isn't a 2091 * valid offset value. 2092 */ 2093 if (ice_is_bit_set(hw->switch_info->prof_res_bm[prof], 2094 rg_entry->fv_idx[i]) || 2095 rg_entry->fv_idx[i] & ICE_AQ_RECIPE_LKUP_IGNORE || 2096 rg_entry->fv_idx[i] == 0) 2097 continue; 2098 2099 ice_find_prot_off(hw, ICE_BLK_SW, prof, 2100 rg_entry->fv_idx[i], &prot, &off); 2101 lkup_exts->fv_words[fv_word_idx].prot_id = prot; 2102 lkup_exts->fv_words[fv_word_idx].off = off; 2103 lkup_exts->field_mask[fv_word_idx] = 2104 rg_entry->fv_mask[i]; 2105 if (prot == ICE_META_DATA_ID_HW && 2106 off == ICE_TUN_FLAG_MDID_OFF) 2107 vlan = true; 2108 fv_word_idx++; 2109 } 2110 /* populate rg_list with the data from the child entry of this 2111 * recipe 2112 */ 2113 LIST_ADD(&rg_entry->l_entry, &recps[rid].rg_list); 2114 2115 /* Propagate some data to the recipe database */ 2116 recps[idx].is_root = !!is_root; 2117 recps[idx].priority = root_bufs.content.act_ctrl_fwd_priority; 2118 ice_zero_bitmap(recps[idx].res_idxs, ICE_MAX_FV_WORDS); 2119 if (root_bufs.content.result_indx & ICE_AQ_RECIPE_RESULT_EN) { 2120 recps[idx].chain_idx = root_bufs.content.result_indx & 2121 ~ICE_AQ_RECIPE_RESULT_EN; 2122 ice_set_bit(recps[idx].chain_idx, recps[idx].res_idxs); 2123 } else { 2124 recps[idx].chain_idx = ICE_INVAL_CHAIN_IND; 2125 } 2126 2127 if (!is_root) 2128 continue; 2129 2130 /* Only do the following for root recipes entries */ 2131 ice_memcpy(recps[idx].r_bitmap, root_bufs.recipe_bitmap, 2132 sizeof(recps[idx].r_bitmap), ICE_NONDMA_TO_NONDMA); 2133 recps[idx].root_rid = root_bufs.content.rid & 2134 ~ICE_AQ_RECIPE_ID_IS_ROOT; 2135 recps[idx].priority = root_bufs.content.act_ctrl_fwd_priority; 2136 } 2137 2138 /* Complete initialization of the root recipe entry */ 2139 lkup_exts->n_val_words = fv_word_idx; 2140 recps[rid].big_recp = (num_recps > 1); 2141 recps[rid].n_grp_count = (u8)num_recps; 2142 recps[rid].tun_type = ice_get_tun_type_for_recipe(rid, vlan); 2143 recps[rid].root_buf = (struct ice_aqc_recipe_data_elem *) 2144 ice_memdup(hw, tmp, recps[rid].n_grp_count * 2145 sizeof(*recps[rid].root_buf), ICE_NONDMA_TO_NONDMA); 2146 if (!recps[rid].root_buf) 2147 goto err_unroll; 2148 2149 /* Copy result indexes */ 2150 ice_cp_bitmap(recps[rid].res_idxs, result_bm, ICE_MAX_FV_WORDS); 2151 recps[rid].recp_created = true; 2152 2153 err_unroll: 2154 ice_free(hw, tmp); 2155 return status; 2156 } 2157 2158 /** 2159 * ice_get_recp_to_prof_map - updates recipe to profile mapping 2160 * @hw: pointer to hardware structure 2161 * 2162 * This function is used to populate recipe_to_profile matrix where index to 2163 * this array is the recipe ID and the element is the mapping of which profiles 2164 * is this recipe mapped to. 2165 */ 2166 static void ice_get_recp_to_prof_map(struct ice_hw *hw) 2167 { 2168 ice_declare_bitmap(r_bitmap, ICE_MAX_NUM_RECIPES); 2169 u16 i; 2170 2171 for (i = 0; i < hw->switch_info->max_used_prof_index + 1; i++) { 2172 u16 j; 2173 2174 ice_zero_bitmap(profile_to_recipe[i], ICE_MAX_NUM_RECIPES); 2175 ice_zero_bitmap(r_bitmap, ICE_MAX_NUM_RECIPES); 2176 if (ice_aq_get_recipe_to_profile(hw, i, (u8 *)r_bitmap, NULL)) 2177 continue; 2178 ice_cp_bitmap(profile_to_recipe[i], r_bitmap, 2179 ICE_MAX_NUM_RECIPES); 2180 ice_for_each_set_bit(j, r_bitmap, ICE_MAX_NUM_RECIPES) 2181 ice_set_bit(i, recipe_to_profile[j]); 2182 } 2183 } 2184 2185 /** 2186 * ice_init_def_sw_recp - initialize the recipe book keeping tables 2187 * @hw: pointer to the HW struct 2188 * @recp_list: pointer to sw recipe list 2189 * 2190 * Allocate memory for the entire recipe table and initialize the structures/ 2191 * entries corresponding to basic recipes. 2192 */ 2193 enum ice_status 2194 ice_init_def_sw_recp(struct ice_hw *hw, struct ice_sw_recipe **recp_list) 2195 { 2196 struct ice_sw_recipe *recps; 2197 u8 i; 2198 2199 recps = (struct ice_sw_recipe *) 2200 ice_calloc(hw, ICE_MAX_NUM_RECIPES, sizeof(*recps)); 2201 if (!recps) 2202 return ICE_ERR_NO_MEMORY; 2203 2204 for (i = 0; i < ICE_MAX_NUM_RECIPES; i++) { 2205 recps[i].root_rid = i; 2206 INIT_LIST_HEAD(&recps[i].filt_rules); 2207 INIT_LIST_HEAD(&recps[i].filt_replay_rules); 2208 INIT_LIST_HEAD(&recps[i].rg_list); 2209 ice_init_lock(&recps[i].filt_rule_lock); 2210 } 2211 2212 *recp_list = recps; 2213 2214 return ICE_SUCCESS; 2215 } 2216 2217 /** 2218 * ice_aq_get_sw_cfg - get switch configuration 2219 * @hw: pointer to the hardware structure 2220 * @buf: pointer to the result buffer 2221 * @buf_size: length of the buffer available for response 2222 * @req_desc: pointer to requested descriptor 2223 * @num_elems: pointer to number of elements 2224 * @cd: pointer to command details structure or NULL 2225 * 2226 * Get switch configuration (0x0200) to be placed in buf. 2227 * This admin command returns information such as initial VSI/port number 2228 * and switch ID it belongs to. 2229 * 2230 * NOTE: *req_desc is both an input/output parameter. 2231 * The caller of this function first calls this function with *request_desc set 2232 * to 0. If the response from f/w has *req_desc set to 0, all the switch 2233 * configuration information has been returned; if non-zero (meaning not all 2234 * the information was returned), the caller should call this function again 2235 * with *req_desc set to the previous value returned by f/w to get the 2236 * next block of switch configuration information. 2237 * 2238 * *num_elems is output only parameter. This reflects the number of elements 2239 * in response buffer. The caller of this function to use *num_elems while 2240 * parsing the response buffer. 2241 */ 2242 static enum ice_status 2243 ice_aq_get_sw_cfg(struct ice_hw *hw, struct ice_aqc_get_sw_cfg_resp_elem *buf, 2244 u16 buf_size, u16 *req_desc, u16 *num_elems, 2245 struct ice_sq_cd *cd) 2246 { 2247 struct ice_aqc_get_sw_cfg *cmd; 2248 struct ice_aq_desc desc; 2249 enum ice_status status; 2250 2251 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_sw_cfg); 2252 cmd = &desc.params.get_sw_conf; 2253 cmd->element = CPU_TO_LE16(*req_desc); 2254 2255 status = ice_aq_send_cmd(hw, &desc, buf, buf_size, cd); 2256 if (!status) { 2257 *req_desc = LE16_TO_CPU(cmd->element); 2258 *num_elems = LE16_TO_CPU(cmd->num_elems); 2259 } 2260 2261 return status; 2262 } 2263 2264 /** 2265 * ice_alloc_rss_global_lut - allocate a RSS global LUT 2266 * @hw: pointer to the HW struct 2267 * @shared_res: true to allocate as a shared resource and false to allocate as a dedicated resource 2268 * @global_lut_id: output parameter for the RSS global LUT's ID 2269 */ 2270 enum ice_status ice_alloc_rss_global_lut(struct ice_hw *hw, bool shared_res, u16 *global_lut_id) 2271 { 2272 struct ice_aqc_alloc_free_res_elem *sw_buf; 2273 enum ice_status status; 2274 u16 buf_len; 2275 2276 buf_len = ice_struct_size(sw_buf, elem, 1); 2277 sw_buf = (struct ice_aqc_alloc_free_res_elem *)ice_malloc(hw, buf_len); 2278 if (!sw_buf) 2279 return ICE_ERR_NO_MEMORY; 2280 2281 sw_buf->num_elems = CPU_TO_LE16(1); 2282 sw_buf->res_type = CPU_TO_LE16(ICE_AQC_RES_TYPE_GLOBAL_RSS_HASH | 2283 (shared_res ? ICE_AQC_RES_TYPE_FLAG_SHARED : 2284 ICE_AQC_RES_TYPE_FLAG_DEDICATED)); 2285 2286 status = ice_aq_alloc_free_res(hw, 1, sw_buf, buf_len, ice_aqc_opc_alloc_res, NULL); 2287 if (status) { 2288 ice_debug(hw, ICE_DBG_RES, "Failed to allocate %s RSS global LUT, status %d\n", 2289 shared_res ? "shared" : "dedicated", status); 2290 goto ice_alloc_global_lut_exit; 2291 } 2292 2293 *global_lut_id = LE16_TO_CPU(sw_buf->elem[0].e.sw_resp); 2294 2295 ice_alloc_global_lut_exit: 2296 ice_free(hw, sw_buf); 2297 return status; 2298 } 2299 2300 /** 2301 * ice_free_global_lut - free a RSS global LUT 2302 * @hw: pointer to the HW struct 2303 * @global_lut_id: ID of the RSS global LUT to free 2304 */ 2305 enum ice_status ice_free_rss_global_lut(struct ice_hw *hw, u16 global_lut_id) 2306 { 2307 struct ice_aqc_alloc_free_res_elem *sw_buf; 2308 u16 buf_len, num_elems = 1; 2309 enum ice_status status; 2310 2311 buf_len = ice_struct_size(sw_buf, elem, num_elems); 2312 sw_buf = (struct ice_aqc_alloc_free_res_elem *)ice_malloc(hw, buf_len); 2313 if (!sw_buf) 2314 return ICE_ERR_NO_MEMORY; 2315 2316 sw_buf->num_elems = CPU_TO_LE16(num_elems); 2317 sw_buf->res_type = CPU_TO_LE16(ICE_AQC_RES_TYPE_GLOBAL_RSS_HASH); 2318 sw_buf->elem[0].e.sw_resp = CPU_TO_LE16(global_lut_id); 2319 2320 status = ice_aq_alloc_free_res(hw, num_elems, sw_buf, buf_len, ice_aqc_opc_free_res, NULL); 2321 if (status) 2322 ice_debug(hw, ICE_DBG_RES, "Failed to free RSS global LUT %d, status %d\n", 2323 global_lut_id, status); 2324 2325 ice_free(hw, sw_buf); 2326 return status; 2327 } 2328 2329 /** 2330 * ice_alloc_sw - allocate resources specific to switch 2331 * @hw: pointer to the HW struct 2332 * @ena_stats: true to turn on VEB stats 2333 * @shared_res: true for shared resource, false for dedicated resource 2334 * @sw_id: switch ID returned 2335 * @counter_id: VEB counter ID returned 2336 * 2337 * allocates switch resources (SWID and VEB counter) (0x0208) 2338 */ 2339 enum ice_status 2340 ice_alloc_sw(struct ice_hw *hw, bool ena_stats, bool shared_res, u16 *sw_id, 2341 u16 *counter_id) 2342 { 2343 struct ice_aqc_alloc_free_res_elem *sw_buf; 2344 struct ice_aqc_res_elem *sw_ele; 2345 enum ice_status status; 2346 u16 buf_len; 2347 2348 buf_len = ice_struct_size(sw_buf, elem, 1); 2349 sw_buf = (struct ice_aqc_alloc_free_res_elem *)ice_malloc(hw, buf_len); 2350 if (!sw_buf) 2351 return ICE_ERR_NO_MEMORY; 2352 2353 /* Prepare buffer for switch ID. 2354 * The number of resource entries in buffer is passed as 1 since only a 2355 * single switch/VEB instance is allocated, and hence a single sw_id 2356 * is requested. 2357 */ 2358 sw_buf->num_elems = CPU_TO_LE16(1); 2359 sw_buf->res_type = 2360 CPU_TO_LE16(ICE_AQC_RES_TYPE_SWID | 2361 (shared_res ? ICE_AQC_RES_TYPE_FLAG_SHARED : 2362 ICE_AQC_RES_TYPE_FLAG_DEDICATED)); 2363 2364 status = ice_aq_alloc_free_res(hw, 1, sw_buf, buf_len, 2365 ice_aqc_opc_alloc_res, NULL); 2366 2367 if (status) 2368 goto ice_alloc_sw_exit; 2369 2370 sw_ele = &sw_buf->elem[0]; 2371 *sw_id = LE16_TO_CPU(sw_ele->e.sw_resp); 2372 2373 if (ena_stats) { 2374 /* Prepare buffer for VEB Counter */ 2375 enum ice_adminq_opc opc = ice_aqc_opc_alloc_res; 2376 struct ice_aqc_alloc_free_res_elem *counter_buf; 2377 struct ice_aqc_res_elem *counter_ele; 2378 2379 counter_buf = (struct ice_aqc_alloc_free_res_elem *) 2380 ice_malloc(hw, buf_len); 2381 if (!counter_buf) { 2382 status = ICE_ERR_NO_MEMORY; 2383 goto ice_alloc_sw_exit; 2384 } 2385 2386 /* The number of resource entries in buffer is passed as 1 since 2387 * only a single switch/VEB instance is allocated, and hence a 2388 * single VEB counter is requested. 2389 */ 2390 counter_buf->num_elems = CPU_TO_LE16(1); 2391 counter_buf->res_type = 2392 CPU_TO_LE16(ICE_AQC_RES_TYPE_VEB_COUNTER | 2393 ICE_AQC_RES_TYPE_FLAG_DEDICATED); 2394 status = ice_aq_alloc_free_res(hw, 1, counter_buf, buf_len, 2395 opc, NULL); 2396 2397 if (status) { 2398 ice_free(hw, counter_buf); 2399 goto ice_alloc_sw_exit; 2400 } 2401 counter_ele = &counter_buf->elem[0]; 2402 *counter_id = LE16_TO_CPU(counter_ele->e.sw_resp); 2403 ice_free(hw, counter_buf); 2404 } 2405 2406 ice_alloc_sw_exit: 2407 ice_free(hw, sw_buf); 2408 return status; 2409 } 2410 2411 /** 2412 * ice_free_sw - free resources specific to switch 2413 * @hw: pointer to the HW struct 2414 * @sw_id: switch ID returned 2415 * @counter_id: VEB counter ID returned 2416 * 2417 * free switch resources (SWID and VEB counter) (0x0209) 2418 * 2419 * NOTE: This function frees multiple resources. It continues 2420 * releasing other resources even after it encounters error. 2421 * The error code returned is the last error it encountered. 2422 */ 2423 enum ice_status ice_free_sw(struct ice_hw *hw, u16 sw_id, u16 counter_id) 2424 { 2425 struct ice_aqc_alloc_free_res_elem *sw_buf, *counter_buf; 2426 enum ice_status status, ret_status; 2427 u16 buf_len; 2428 2429 buf_len = ice_struct_size(sw_buf, elem, 1); 2430 sw_buf = (struct ice_aqc_alloc_free_res_elem *)ice_malloc(hw, buf_len); 2431 if (!sw_buf) 2432 return ICE_ERR_NO_MEMORY; 2433 2434 /* Prepare buffer to free for switch ID res. 2435 * The number of resource entries in buffer is passed as 1 since only a 2436 * single switch/VEB instance is freed, and hence a single sw_id 2437 * is released. 2438 */ 2439 sw_buf->num_elems = CPU_TO_LE16(1); 2440 sw_buf->res_type = CPU_TO_LE16(ICE_AQC_RES_TYPE_SWID); 2441 sw_buf->elem[0].e.sw_resp = CPU_TO_LE16(sw_id); 2442 2443 ret_status = ice_aq_alloc_free_res(hw, 1, sw_buf, buf_len, 2444 ice_aqc_opc_free_res, NULL); 2445 2446 if (ret_status) 2447 ice_debug(hw, ICE_DBG_SW, "CQ CMD Buffer:\n"); 2448 2449 /* Prepare buffer to free for VEB Counter resource */ 2450 counter_buf = (struct ice_aqc_alloc_free_res_elem *) 2451 ice_malloc(hw, buf_len); 2452 if (!counter_buf) { 2453 ice_free(hw, sw_buf); 2454 return ICE_ERR_NO_MEMORY; 2455 } 2456 2457 /* The number of resource entries in buffer is passed as 1 since only a 2458 * single switch/VEB instance is freed, and hence a single VEB counter 2459 * is released 2460 */ 2461 counter_buf->num_elems = CPU_TO_LE16(1); 2462 counter_buf->res_type = CPU_TO_LE16(ICE_AQC_RES_TYPE_VEB_COUNTER); 2463 counter_buf->elem[0].e.sw_resp = CPU_TO_LE16(counter_id); 2464 2465 status = ice_aq_alloc_free_res(hw, 1, counter_buf, buf_len, 2466 ice_aqc_opc_free_res, NULL); 2467 if (status) { 2468 ice_debug(hw, ICE_DBG_SW, "VEB counter resource could not be freed\n"); 2469 ret_status = status; 2470 } 2471 2472 ice_free(hw, counter_buf); 2473 ice_free(hw, sw_buf); 2474 return ret_status; 2475 } 2476 2477 /** 2478 * ice_aq_add_vsi 2479 * @hw: pointer to the HW struct 2480 * @vsi_ctx: pointer to a VSI context struct 2481 * @cd: pointer to command details structure or NULL 2482 * 2483 * Add a VSI context to the hardware (0x0210) 2484 */ 2485 enum ice_status 2486 ice_aq_add_vsi(struct ice_hw *hw, struct ice_vsi_ctx *vsi_ctx, 2487 struct ice_sq_cd *cd) 2488 { 2489 struct ice_aqc_add_update_free_vsi_resp *res; 2490 struct ice_aqc_add_get_update_free_vsi *cmd; 2491 struct ice_aq_desc desc; 2492 enum ice_status status; 2493 2494 cmd = &desc.params.vsi_cmd; 2495 res = &desc.params.add_update_free_vsi_res; 2496 2497 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_add_vsi); 2498 2499 if (!vsi_ctx->alloc_from_pool) 2500 cmd->vsi_num = CPU_TO_LE16(vsi_ctx->vsi_num | 2501 ICE_AQ_VSI_IS_VALID); 2502 2503 cmd->vsi_flags = CPU_TO_LE16(vsi_ctx->flags); 2504 2505 desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD); 2506 2507 status = ice_aq_send_cmd(hw, &desc, &vsi_ctx->info, 2508 sizeof(vsi_ctx->info), cd); 2509 2510 if (!status) { 2511 vsi_ctx->vsi_num = LE16_TO_CPU(res->vsi_num) & ICE_AQ_VSI_NUM_M; 2512 vsi_ctx->vsis_allocd = LE16_TO_CPU(res->vsi_used); 2513 vsi_ctx->vsis_unallocated = LE16_TO_CPU(res->vsi_free); 2514 } 2515 2516 return status; 2517 } 2518 2519 /** 2520 * ice_aq_free_vsi 2521 * @hw: pointer to the HW struct 2522 * @vsi_ctx: pointer to a VSI context struct 2523 * @keep_vsi_alloc: keep VSI allocation as part of this PF's resources 2524 * @cd: pointer to command details structure or NULL 2525 * 2526 * Free VSI context info from hardware (0x0213) 2527 */ 2528 enum ice_status 2529 ice_aq_free_vsi(struct ice_hw *hw, struct ice_vsi_ctx *vsi_ctx, 2530 bool keep_vsi_alloc, struct ice_sq_cd *cd) 2531 { 2532 struct ice_aqc_add_update_free_vsi_resp *resp; 2533 struct ice_aqc_add_get_update_free_vsi *cmd; 2534 struct ice_aq_desc desc; 2535 enum ice_status status; 2536 2537 cmd = &desc.params.vsi_cmd; 2538 resp = &desc.params.add_update_free_vsi_res; 2539 2540 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_free_vsi); 2541 2542 cmd->vsi_num = CPU_TO_LE16(vsi_ctx->vsi_num | ICE_AQ_VSI_IS_VALID); 2543 if (keep_vsi_alloc) 2544 cmd->cmd_flags = CPU_TO_LE16(ICE_AQ_VSI_KEEP_ALLOC); 2545 2546 status = ice_aq_send_cmd(hw, &desc, NULL, 0, cd); 2547 if (!status) { 2548 vsi_ctx->vsis_allocd = LE16_TO_CPU(resp->vsi_used); 2549 vsi_ctx->vsis_unallocated = LE16_TO_CPU(resp->vsi_free); 2550 } 2551 2552 return status; 2553 } 2554 2555 /** 2556 * ice_aq_update_vsi 2557 * @hw: pointer to the HW struct 2558 * @vsi_ctx: pointer to a VSI context struct 2559 * @cd: pointer to command details structure or NULL 2560 * 2561 * Update VSI context in the hardware (0x0211) 2562 */ 2563 enum ice_status 2564 ice_aq_update_vsi(struct ice_hw *hw, struct ice_vsi_ctx *vsi_ctx, 2565 struct ice_sq_cd *cd) 2566 { 2567 struct ice_aqc_add_update_free_vsi_resp *resp; 2568 struct ice_aqc_add_get_update_free_vsi *cmd; 2569 struct ice_aq_desc desc; 2570 enum ice_status status; 2571 2572 cmd = &desc.params.vsi_cmd; 2573 resp = &desc.params.add_update_free_vsi_res; 2574 2575 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_update_vsi); 2576 2577 cmd->vsi_num = CPU_TO_LE16(vsi_ctx->vsi_num | ICE_AQ_VSI_IS_VALID); 2578 2579 desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD); 2580 2581 status = ice_aq_send_cmd(hw, &desc, &vsi_ctx->info, 2582 sizeof(vsi_ctx->info), cd); 2583 2584 if (!status) { 2585 vsi_ctx->vsis_allocd = LE16_TO_CPU(resp->vsi_used); 2586 vsi_ctx->vsis_unallocated = LE16_TO_CPU(resp->vsi_free); 2587 } 2588 2589 return status; 2590 } 2591 2592 /** 2593 * ice_is_vsi_valid - check whether the VSI is valid or not 2594 * @hw: pointer to the HW struct 2595 * @vsi_handle: VSI handle 2596 * 2597 * check whether the VSI is valid or not 2598 */ 2599 bool ice_is_vsi_valid(struct ice_hw *hw, u16 vsi_handle) 2600 { 2601 return vsi_handle < ICE_MAX_VSI && hw->vsi_ctx[vsi_handle]; 2602 } 2603 2604 /** 2605 * ice_get_hw_vsi_num - return the HW VSI number 2606 * @hw: pointer to the HW struct 2607 * @vsi_handle: VSI handle 2608 * 2609 * return the HW VSI number 2610 * Caution: call this function only if VSI is valid (ice_is_vsi_valid) 2611 */ 2612 u16 ice_get_hw_vsi_num(struct ice_hw *hw, u16 vsi_handle) 2613 { 2614 return hw->vsi_ctx[vsi_handle]->vsi_num; 2615 } 2616 2617 /** 2618 * ice_get_vsi_ctx - return the VSI context entry for a given VSI handle 2619 * @hw: pointer to the HW struct 2620 * @vsi_handle: VSI handle 2621 * 2622 * return the VSI context entry for a given VSI handle 2623 */ 2624 struct ice_vsi_ctx *ice_get_vsi_ctx(struct ice_hw *hw, u16 vsi_handle) 2625 { 2626 return (vsi_handle >= ICE_MAX_VSI) ? NULL : hw->vsi_ctx[vsi_handle]; 2627 } 2628 2629 /** 2630 * ice_save_vsi_ctx - save the VSI context for a given VSI handle 2631 * @hw: pointer to the HW struct 2632 * @vsi_handle: VSI handle 2633 * @vsi: VSI context pointer 2634 * 2635 * save the VSI context entry for a given VSI handle 2636 */ 2637 static void 2638 ice_save_vsi_ctx(struct ice_hw *hw, u16 vsi_handle, struct ice_vsi_ctx *vsi) 2639 { 2640 hw->vsi_ctx[vsi_handle] = vsi; 2641 } 2642 2643 /** 2644 * ice_clear_vsi_q_ctx - clear VSI queue contexts for all TCs 2645 * @hw: pointer to the HW struct 2646 * @vsi_handle: VSI handle 2647 */ 2648 static void ice_clear_vsi_q_ctx(struct ice_hw *hw, u16 vsi_handle) 2649 { 2650 struct ice_vsi_ctx *vsi; 2651 u8 i; 2652 2653 vsi = ice_get_vsi_ctx(hw, vsi_handle); 2654 if (!vsi) 2655 return; 2656 ice_for_each_traffic_class(i) { 2657 if (vsi->lan_q_ctx[i]) { 2658 ice_free(hw, vsi->lan_q_ctx[i]); 2659 vsi->lan_q_ctx[i] = NULL; 2660 } 2661 } 2662 } 2663 2664 /** 2665 * ice_clear_vsi_ctx - clear the VSI context entry 2666 * @hw: pointer to the HW struct 2667 * @vsi_handle: VSI handle 2668 * 2669 * clear the VSI context entry 2670 */ 2671 static void ice_clear_vsi_ctx(struct ice_hw *hw, u16 vsi_handle) 2672 { 2673 struct ice_vsi_ctx *vsi; 2674 2675 vsi = ice_get_vsi_ctx(hw, vsi_handle); 2676 if (vsi) { 2677 ice_clear_vsi_q_ctx(hw, vsi_handle); 2678 ice_free(hw, vsi); 2679 hw->vsi_ctx[vsi_handle] = NULL; 2680 } 2681 } 2682 2683 /** 2684 * ice_clear_all_vsi_ctx - clear all the VSI context entries 2685 * @hw: pointer to the HW struct 2686 */ 2687 void ice_clear_all_vsi_ctx(struct ice_hw *hw) 2688 { 2689 u16 i; 2690 2691 for (i = 0; i < ICE_MAX_VSI; i++) 2692 ice_clear_vsi_ctx(hw, i); 2693 } 2694 2695 /** 2696 * ice_add_vsi - add VSI context to the hardware and VSI handle list 2697 * @hw: pointer to the HW struct 2698 * @vsi_handle: unique VSI handle provided by drivers 2699 * @vsi_ctx: pointer to a VSI context struct 2700 * @cd: pointer to command details structure or NULL 2701 * 2702 * Add a VSI context to the hardware also add it into the VSI handle list. 2703 * If this function gets called after reset for existing VSIs then update 2704 * with the new HW VSI number in the corresponding VSI handle list entry. 2705 */ 2706 enum ice_status 2707 ice_add_vsi(struct ice_hw *hw, u16 vsi_handle, struct ice_vsi_ctx *vsi_ctx, 2708 struct ice_sq_cd *cd) 2709 { 2710 struct ice_vsi_ctx *tmp_vsi_ctx; 2711 enum ice_status status; 2712 2713 if (vsi_handle >= ICE_MAX_VSI) 2714 return ICE_ERR_PARAM; 2715 status = ice_aq_add_vsi(hw, vsi_ctx, cd); 2716 if (status) 2717 return status; 2718 tmp_vsi_ctx = ice_get_vsi_ctx(hw, vsi_handle); 2719 if (!tmp_vsi_ctx) { 2720 /* Create a new VSI context */ 2721 tmp_vsi_ctx = (struct ice_vsi_ctx *) 2722 ice_malloc(hw, sizeof(*tmp_vsi_ctx)); 2723 if (!tmp_vsi_ctx) { 2724 ice_aq_free_vsi(hw, vsi_ctx, false, cd); 2725 return ICE_ERR_NO_MEMORY; 2726 } 2727 *tmp_vsi_ctx = *vsi_ctx; 2728 2729 ice_save_vsi_ctx(hw, vsi_handle, tmp_vsi_ctx); 2730 } else { 2731 /* update with new HW VSI num */ 2732 tmp_vsi_ctx->vsi_num = vsi_ctx->vsi_num; 2733 } 2734 2735 return ICE_SUCCESS; 2736 } 2737 2738 /** 2739 * ice_free_vsi- free VSI context from hardware and VSI handle list 2740 * @hw: pointer to the HW struct 2741 * @vsi_handle: unique VSI handle 2742 * @vsi_ctx: pointer to a VSI context struct 2743 * @keep_vsi_alloc: keep VSI allocation as part of this PF's resources 2744 * @cd: pointer to command details structure or NULL 2745 * 2746 * Free VSI context info from hardware as well as from VSI handle list 2747 */ 2748 enum ice_status 2749 ice_free_vsi(struct ice_hw *hw, u16 vsi_handle, struct ice_vsi_ctx *vsi_ctx, 2750 bool keep_vsi_alloc, struct ice_sq_cd *cd) 2751 { 2752 enum ice_status status; 2753 2754 if (!ice_is_vsi_valid(hw, vsi_handle)) 2755 return ICE_ERR_PARAM; 2756 vsi_ctx->vsi_num = ice_get_hw_vsi_num(hw, vsi_handle); 2757 status = ice_aq_free_vsi(hw, vsi_ctx, keep_vsi_alloc, cd); 2758 if (!status) 2759 ice_clear_vsi_ctx(hw, vsi_handle); 2760 return status; 2761 } 2762 2763 /** 2764 * ice_update_vsi 2765 * @hw: pointer to the HW struct 2766 * @vsi_handle: unique VSI handle 2767 * @vsi_ctx: pointer to a VSI context struct 2768 * @cd: pointer to command details structure or NULL 2769 * 2770 * Update VSI context in the hardware 2771 */ 2772 enum ice_status 2773 ice_update_vsi(struct ice_hw *hw, u16 vsi_handle, struct ice_vsi_ctx *vsi_ctx, 2774 struct ice_sq_cd *cd) 2775 { 2776 if (!ice_is_vsi_valid(hw, vsi_handle)) 2777 return ICE_ERR_PARAM; 2778 vsi_ctx->vsi_num = ice_get_hw_vsi_num(hw, vsi_handle); 2779 return ice_aq_update_vsi(hw, vsi_ctx, cd); 2780 } 2781 2782 /** 2783 * ice_aq_get_vsi_params 2784 * @hw: pointer to the HW struct 2785 * @vsi_ctx: pointer to a VSI context struct 2786 * @cd: pointer to command details structure or NULL 2787 * 2788 * Get VSI context info from hardware (0x0212) 2789 */ 2790 enum ice_status 2791 ice_aq_get_vsi_params(struct ice_hw *hw, struct ice_vsi_ctx *vsi_ctx, 2792 struct ice_sq_cd *cd) 2793 { 2794 struct ice_aqc_add_get_update_free_vsi *cmd; 2795 struct ice_aqc_get_vsi_resp *resp; 2796 struct ice_aq_desc desc; 2797 enum ice_status status; 2798 2799 cmd = &desc.params.vsi_cmd; 2800 resp = &desc.params.get_vsi_resp; 2801 2802 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_vsi_params); 2803 2804 cmd->vsi_num = CPU_TO_LE16(vsi_ctx->vsi_num | ICE_AQ_VSI_IS_VALID); 2805 2806 status = ice_aq_send_cmd(hw, &desc, &vsi_ctx->info, 2807 sizeof(vsi_ctx->info), cd); 2808 if (!status) { 2809 vsi_ctx->vsi_num = LE16_TO_CPU(resp->vsi_num) & 2810 ICE_AQ_VSI_NUM_M; 2811 vsi_ctx->vsis_allocd = LE16_TO_CPU(resp->vsi_used); 2812 vsi_ctx->vsis_unallocated = LE16_TO_CPU(resp->vsi_free); 2813 } 2814 2815 return status; 2816 } 2817 2818 /** 2819 * ice_aq_add_update_mir_rule - add/update a mirror rule 2820 * @hw: pointer to the HW struct 2821 * @rule_type: Rule Type 2822 * @dest_vsi: VSI number to which packets will be mirrored 2823 * @count: length of the list 2824 * @mr_buf: buffer for list of mirrored VSI numbers 2825 * @cd: pointer to command details structure or NULL 2826 * @rule_id: Rule ID 2827 * 2828 * Add/Update Mirror Rule (0x260). 2829 */ 2830 enum ice_status 2831 ice_aq_add_update_mir_rule(struct ice_hw *hw, u16 rule_type, u16 dest_vsi, 2832 u16 count, struct ice_mir_rule_buf *mr_buf, 2833 struct ice_sq_cd *cd, u16 *rule_id) 2834 { 2835 struct ice_aqc_add_update_mir_rule *cmd; 2836 struct ice_aq_desc desc; 2837 enum ice_status status; 2838 __le16 *mr_list = NULL; 2839 u16 buf_size = 0; 2840 2841 switch (rule_type) { 2842 case ICE_AQC_RULE_TYPE_VPORT_INGRESS: 2843 case ICE_AQC_RULE_TYPE_VPORT_EGRESS: 2844 /* Make sure count and mr_buf are set for these rule_types */ 2845 if (!(count && mr_buf)) 2846 return ICE_ERR_PARAM; 2847 2848 buf_size = count * sizeof(__le16); 2849 mr_list = (_FORCE_ __le16 *)ice_malloc(hw, buf_size); 2850 if (!mr_list) 2851 return ICE_ERR_NO_MEMORY; 2852 break; 2853 case ICE_AQC_RULE_TYPE_PPORT_INGRESS: 2854 case ICE_AQC_RULE_TYPE_PPORT_EGRESS: 2855 /* Make sure count and mr_buf are not set for these 2856 * rule_types 2857 */ 2858 if (count || mr_buf) 2859 return ICE_ERR_PARAM; 2860 break; 2861 default: 2862 ice_debug(hw, ICE_DBG_SW, "Error due to unsupported rule_type %u\n", rule_type); 2863 return ICE_ERR_OUT_OF_RANGE; 2864 } 2865 2866 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_add_update_mir_rule); 2867 2868 /* Pre-process 'mr_buf' items for add/update of virtual port 2869 * ingress/egress mirroring (but not physical port ingress/egress 2870 * mirroring) 2871 */ 2872 if (mr_buf) { 2873 int i; 2874 2875 for (i = 0; i < count; i++) { 2876 u16 id; 2877 2878 id = mr_buf[i].vsi_idx & ICE_AQC_RULE_MIRRORED_VSI_M; 2879 2880 /* Validate specified VSI number, make sure it is less 2881 * than ICE_MAX_VSI, if not return with error. 2882 */ 2883 if (id >= ICE_MAX_VSI) { 2884 ice_debug(hw, ICE_DBG_SW, "Error VSI index (%u) out-of-range\n", 2885 id); 2886 ice_free(hw, mr_list); 2887 return ICE_ERR_OUT_OF_RANGE; 2888 } 2889 2890 /* add VSI to mirror rule */ 2891 if (mr_buf[i].add) 2892 mr_list[i] = 2893 CPU_TO_LE16(id | ICE_AQC_RULE_ACT_M); 2894 else /* remove VSI from mirror rule */ 2895 mr_list[i] = CPU_TO_LE16(id); 2896 } 2897 } 2898 2899 cmd = &desc.params.add_update_rule; 2900 if ((*rule_id) != ICE_INVAL_MIRROR_RULE_ID) 2901 cmd->rule_id = CPU_TO_LE16(((*rule_id) & ICE_AQC_RULE_ID_M) | 2902 ICE_AQC_RULE_ID_VALID_M); 2903 cmd->rule_type = CPU_TO_LE16(rule_type & ICE_AQC_RULE_TYPE_M); 2904 cmd->num_entries = CPU_TO_LE16(count); 2905 cmd->dest = CPU_TO_LE16(dest_vsi); 2906 2907 status = ice_aq_send_cmd(hw, &desc, mr_list, buf_size, cd); 2908 if (!status) 2909 *rule_id = LE16_TO_CPU(cmd->rule_id) & ICE_AQC_RULE_ID_M; 2910 2911 ice_free(hw, mr_list); 2912 2913 return status; 2914 } 2915 2916 /** 2917 * ice_aq_delete_mir_rule - delete a mirror rule 2918 * @hw: pointer to the HW struct 2919 * @rule_id: Mirror rule ID (to be deleted) 2920 * @keep_allocd: if set, the VSI stays part of the PF allocated res, 2921 * otherwise it is returned to the shared pool 2922 * @cd: pointer to command details structure or NULL 2923 * 2924 * Delete Mirror Rule (0x261). 2925 */ 2926 enum ice_status 2927 ice_aq_delete_mir_rule(struct ice_hw *hw, u16 rule_id, bool keep_allocd, 2928 struct ice_sq_cd *cd) 2929 { 2930 struct ice_aqc_delete_mir_rule *cmd; 2931 struct ice_aq_desc desc; 2932 2933 /* rule_id should be in the range 0...63 */ 2934 if (rule_id >= ICE_MAX_NUM_MIRROR_RULES) 2935 return ICE_ERR_OUT_OF_RANGE; 2936 2937 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_del_mir_rule); 2938 2939 cmd = &desc.params.del_rule; 2940 rule_id |= ICE_AQC_RULE_ID_VALID_M; 2941 cmd->rule_id = CPU_TO_LE16(rule_id); 2942 2943 if (keep_allocd) 2944 cmd->flags = CPU_TO_LE16(ICE_AQC_FLAG_KEEP_ALLOCD_M); 2945 2946 return ice_aq_send_cmd(hw, &desc, NULL, 0, cd); 2947 } 2948 2949 /** 2950 * ice_aq_alloc_free_vsi_list 2951 * @hw: pointer to the HW struct 2952 * @vsi_list_id: VSI list ID returned or used for lookup 2953 * @lkup_type: switch rule filter lookup type 2954 * @opc: switch rules population command type - pass in the command opcode 2955 * 2956 * allocates or free a VSI list resource 2957 */ 2958 static enum ice_status 2959 ice_aq_alloc_free_vsi_list(struct ice_hw *hw, u16 *vsi_list_id, 2960 enum ice_sw_lkup_type lkup_type, 2961 enum ice_adminq_opc opc) 2962 { 2963 struct ice_aqc_alloc_free_res_elem *sw_buf; 2964 struct ice_aqc_res_elem *vsi_ele; 2965 enum ice_status status; 2966 u16 buf_len; 2967 2968 buf_len = ice_struct_size(sw_buf, elem, 1); 2969 sw_buf = (struct ice_aqc_alloc_free_res_elem *)ice_malloc(hw, buf_len); 2970 if (!sw_buf) 2971 return ICE_ERR_NO_MEMORY; 2972 sw_buf->num_elems = CPU_TO_LE16(1); 2973 2974 if (lkup_type == ICE_SW_LKUP_MAC || 2975 lkup_type == ICE_SW_LKUP_MAC_VLAN || 2976 lkup_type == ICE_SW_LKUP_ETHERTYPE || 2977 lkup_type == ICE_SW_LKUP_ETHERTYPE_MAC || 2978 lkup_type == ICE_SW_LKUP_PROMISC || 2979 lkup_type == ICE_SW_LKUP_PROMISC_VLAN || 2980 lkup_type == ICE_SW_LKUP_LAST) { 2981 sw_buf->res_type = CPU_TO_LE16(ICE_AQC_RES_TYPE_VSI_LIST_REP); 2982 } else if (lkup_type == ICE_SW_LKUP_VLAN) { 2983 sw_buf->res_type = 2984 CPU_TO_LE16(ICE_AQC_RES_TYPE_VSI_LIST_PRUNE); 2985 } else { 2986 status = ICE_ERR_PARAM; 2987 goto ice_aq_alloc_free_vsi_list_exit; 2988 } 2989 2990 if (opc == ice_aqc_opc_free_res) 2991 sw_buf->elem[0].e.sw_resp = CPU_TO_LE16(*vsi_list_id); 2992 2993 status = ice_aq_alloc_free_res(hw, 1, sw_buf, buf_len, opc, NULL); 2994 if (status) 2995 goto ice_aq_alloc_free_vsi_list_exit; 2996 2997 if (opc == ice_aqc_opc_alloc_res) { 2998 vsi_ele = &sw_buf->elem[0]; 2999 *vsi_list_id = LE16_TO_CPU(vsi_ele->e.sw_resp); 3000 } 3001 3002 ice_aq_alloc_free_vsi_list_exit: 3003 ice_free(hw, sw_buf); 3004 return status; 3005 } 3006 3007 /** 3008 * ice_aq_set_storm_ctrl - Sets storm control configuration 3009 * @hw: pointer to the HW struct 3010 * @bcast_thresh: represents the upper threshold for broadcast storm control 3011 * @mcast_thresh: represents the upper threshold for multicast storm control 3012 * @ctl_bitmask: storm control knobs 3013 * 3014 * Sets the storm control configuration (0x0280) 3015 */ 3016 enum ice_status 3017 ice_aq_set_storm_ctrl(struct ice_hw *hw, u32 bcast_thresh, u32 mcast_thresh, 3018 u32 ctl_bitmask) 3019 { 3020 struct ice_aqc_storm_cfg *cmd; 3021 struct ice_aq_desc desc; 3022 3023 cmd = &desc.params.storm_conf; 3024 3025 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_set_storm_cfg); 3026 3027 cmd->bcast_thresh_size = CPU_TO_LE32(bcast_thresh & ICE_AQ_THRESHOLD_M); 3028 cmd->mcast_thresh_size = CPU_TO_LE32(mcast_thresh & ICE_AQ_THRESHOLD_M); 3029 cmd->storm_ctrl_ctrl = CPU_TO_LE32(ctl_bitmask); 3030 3031 return ice_aq_send_cmd(hw, &desc, NULL, 0, NULL); 3032 } 3033 3034 /** 3035 * ice_aq_get_storm_ctrl - gets storm control configuration 3036 * @hw: pointer to the HW struct 3037 * @bcast_thresh: represents the upper threshold for broadcast storm control 3038 * @mcast_thresh: represents the upper threshold for multicast storm control 3039 * @ctl_bitmask: storm control knobs 3040 * 3041 * Gets the storm control configuration (0x0281) 3042 */ 3043 enum ice_status 3044 ice_aq_get_storm_ctrl(struct ice_hw *hw, u32 *bcast_thresh, u32 *mcast_thresh, 3045 u32 *ctl_bitmask) 3046 { 3047 enum ice_status status; 3048 struct ice_aq_desc desc; 3049 3050 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_storm_cfg); 3051 3052 status = ice_aq_send_cmd(hw, &desc, NULL, 0, NULL); 3053 if (!status) { 3054 struct ice_aqc_storm_cfg *resp = &desc.params.storm_conf; 3055 3056 if (bcast_thresh) 3057 *bcast_thresh = LE32_TO_CPU(resp->bcast_thresh_size) & 3058 ICE_AQ_THRESHOLD_M; 3059 if (mcast_thresh) 3060 *mcast_thresh = LE32_TO_CPU(resp->mcast_thresh_size) & 3061 ICE_AQ_THRESHOLD_M; 3062 if (ctl_bitmask) 3063 *ctl_bitmask = LE32_TO_CPU(resp->storm_ctrl_ctrl); 3064 } 3065 3066 return status; 3067 } 3068 3069 /** 3070 * ice_aq_sw_rules - add/update/remove switch rules 3071 * @hw: pointer to the HW struct 3072 * @rule_list: pointer to switch rule population list 3073 * @rule_list_sz: total size of the rule list in bytes 3074 * @num_rules: number of switch rules in the rule_list 3075 * @opc: switch rules population command type - pass in the command opcode 3076 * @cd: pointer to command details structure or NULL 3077 * 3078 * Add(0x02a0)/Update(0x02a1)/Remove(0x02a2) switch rules commands to firmware 3079 */ 3080 static enum ice_status 3081 ice_aq_sw_rules(struct ice_hw *hw, void *rule_list, u16 rule_list_sz, 3082 u8 num_rules, enum ice_adminq_opc opc, struct ice_sq_cd *cd) 3083 { 3084 struct ice_aq_desc desc; 3085 enum ice_status status; 3086 3087 ice_debug(hw, ICE_DBG_TRACE, "%s\n", __func__); 3088 3089 if (opc != ice_aqc_opc_add_sw_rules && 3090 opc != ice_aqc_opc_update_sw_rules && 3091 opc != ice_aqc_opc_remove_sw_rules) 3092 return ICE_ERR_PARAM; 3093 3094 ice_fill_dflt_direct_cmd_desc(&desc, opc); 3095 3096 desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD); 3097 desc.params.sw_rules.num_rules_fltr_entry_index = 3098 CPU_TO_LE16(num_rules); 3099 status = ice_aq_send_cmd(hw, &desc, rule_list, rule_list_sz, cd); 3100 if (opc != ice_aqc_opc_add_sw_rules && 3101 hw->adminq.sq_last_status == ICE_AQ_RC_ENOENT) 3102 status = ICE_ERR_DOES_NOT_EXIST; 3103 3104 return status; 3105 } 3106 3107 /** 3108 * ice_aq_add_recipe - add switch recipe 3109 * @hw: pointer to the HW struct 3110 * @s_recipe_list: pointer to switch rule population list 3111 * @num_recipes: number of switch recipes in the list 3112 * @cd: pointer to command details structure or NULL 3113 * 3114 * Add(0x0290) 3115 */ 3116 enum ice_status 3117 ice_aq_add_recipe(struct ice_hw *hw, 3118 struct ice_aqc_recipe_data_elem *s_recipe_list, 3119 u16 num_recipes, struct ice_sq_cd *cd) 3120 { 3121 struct ice_aqc_add_get_recipe *cmd; 3122 struct ice_aq_desc desc; 3123 u16 buf_size; 3124 3125 ice_debug(hw, ICE_DBG_TRACE, "%s\n", __func__); 3126 cmd = &desc.params.add_get_recipe; 3127 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_add_recipe); 3128 3129 cmd->num_sub_recipes = CPU_TO_LE16(num_recipes); 3130 desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD); 3131 3132 buf_size = num_recipes * sizeof(*s_recipe_list); 3133 3134 return ice_aq_send_cmd(hw, &desc, s_recipe_list, buf_size, cd); 3135 } 3136 3137 /** 3138 * ice_aq_get_recipe - get switch recipe 3139 * @hw: pointer to the HW struct 3140 * @s_recipe_list: pointer to switch rule population list 3141 * @num_recipes: pointer to the number of recipes (input and output) 3142 * @recipe_root: root recipe number of recipe(s) to retrieve 3143 * @cd: pointer to command details structure or NULL 3144 * 3145 * Get(0x0292) 3146 * 3147 * On input, *num_recipes should equal the number of entries in s_recipe_list. 3148 * On output, *num_recipes will equal the number of entries returned in 3149 * s_recipe_list. 3150 * 3151 * The caller must supply enough space in s_recipe_list to hold all possible 3152 * recipes and *num_recipes must equal ICE_MAX_NUM_RECIPES. 3153 */ 3154 enum ice_status 3155 ice_aq_get_recipe(struct ice_hw *hw, 3156 struct ice_aqc_recipe_data_elem *s_recipe_list, 3157 u16 *num_recipes, u16 recipe_root, struct ice_sq_cd *cd) 3158 { 3159 struct ice_aqc_add_get_recipe *cmd; 3160 struct ice_aq_desc desc; 3161 enum ice_status status; 3162 u16 buf_size; 3163 3164 if (*num_recipes != ICE_MAX_NUM_RECIPES) 3165 return ICE_ERR_PARAM; 3166 3167 ice_debug(hw, ICE_DBG_TRACE, "%s\n", __func__); 3168 cmd = &desc.params.add_get_recipe; 3169 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_recipe); 3170 3171 cmd->return_index = CPU_TO_LE16(recipe_root); 3172 cmd->num_sub_recipes = 0; 3173 3174 buf_size = *num_recipes * sizeof(*s_recipe_list); 3175 3176 status = ice_aq_send_cmd(hw, &desc, s_recipe_list, buf_size, cd); 3177 /* cppcheck-suppress constArgument */ 3178 *num_recipes = LE16_TO_CPU(cmd->num_sub_recipes); 3179 3180 return status; 3181 } 3182 3183 /** 3184 * ice_update_recipe_lkup_idx - update a default recipe based on the lkup_idx 3185 * @hw: pointer to the HW struct 3186 * @params: parameters used to update the default recipe 3187 * 3188 * This function only supports updating default recipes and it only supports 3189 * updating a single recipe based on the lkup_idx at a time. 3190 * 3191 * This is done as a read-modify-write operation. First, get the current recipe 3192 * contents based on the recipe's ID. Then modify the field vector index and 3193 * mask if it's valid at the lkup_idx. Finally, use the add recipe AQ to update 3194 * the pre-existing recipe with the modifications. 3195 */ 3196 enum ice_status 3197 ice_update_recipe_lkup_idx(struct ice_hw *hw, 3198 struct ice_update_recipe_lkup_idx_params *params) 3199 { 3200 struct ice_aqc_recipe_data_elem *rcp_list; 3201 u16 num_recps = ICE_MAX_NUM_RECIPES; 3202 enum ice_status status; 3203 3204 rcp_list = (struct ice_aqc_recipe_data_elem *)ice_malloc(hw, num_recps * sizeof(*rcp_list)); 3205 if (!rcp_list) 3206 return ICE_ERR_NO_MEMORY; 3207 3208 /* read current recipe list from firmware */ 3209 rcp_list->recipe_indx = params->rid; 3210 status = ice_aq_get_recipe(hw, rcp_list, &num_recps, params->rid, NULL); 3211 if (status) { 3212 ice_debug(hw, ICE_DBG_SW, "Failed to get recipe %d, status %d\n", 3213 params->rid, status); 3214 goto error_out; 3215 } 3216 3217 /* only modify existing recipe's lkup_idx and mask if valid, while 3218 * leaving all other fields the same, then update the recipe firmware 3219 */ 3220 rcp_list->content.lkup_indx[params->lkup_idx] = params->fv_idx; 3221 if (params->mask_valid) 3222 rcp_list->content.mask[params->lkup_idx] = 3223 CPU_TO_LE16(params->mask); 3224 3225 if (params->ignore_valid) 3226 rcp_list->content.lkup_indx[params->lkup_idx] |= 3227 ICE_AQ_RECIPE_LKUP_IGNORE; 3228 3229 status = ice_aq_add_recipe(hw, &rcp_list[0], 1, NULL); 3230 if (status) 3231 ice_debug(hw, ICE_DBG_SW, "Failed to update recipe %d lkup_idx %d fv_idx %d mask %d mask_valid %s, status %d\n", 3232 params->rid, params->lkup_idx, params->fv_idx, 3233 params->mask, params->mask_valid ? "true" : "false", 3234 status); 3235 3236 error_out: 3237 ice_free(hw, rcp_list); 3238 return status; 3239 } 3240 3241 /** 3242 * ice_aq_map_recipe_to_profile - Map recipe to packet profile 3243 * @hw: pointer to the HW struct 3244 * @profile_id: package profile ID to associate the recipe with 3245 * @r_bitmap: Recipe bitmap filled in and need to be returned as response 3246 * @cd: pointer to command details structure or NULL 3247 * Recipe to profile association (0x0291) 3248 */ 3249 enum ice_status 3250 ice_aq_map_recipe_to_profile(struct ice_hw *hw, u32 profile_id, u8 *r_bitmap, 3251 struct ice_sq_cd *cd) 3252 { 3253 struct ice_aqc_recipe_to_profile *cmd; 3254 struct ice_aq_desc desc; 3255 3256 ice_debug(hw, ICE_DBG_TRACE, "%s\n", __func__); 3257 cmd = &desc.params.recipe_to_profile; 3258 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_recipe_to_profile); 3259 cmd->profile_id = CPU_TO_LE16(profile_id); 3260 /* Set the recipe ID bit in the bitmask to let the device know which 3261 * profile we are associating the recipe to 3262 */ 3263 ice_memcpy(cmd->recipe_assoc, r_bitmap, sizeof(cmd->recipe_assoc), 3264 ICE_NONDMA_TO_NONDMA); 3265 3266 return ice_aq_send_cmd(hw, &desc, NULL, 0, cd); 3267 } 3268 3269 /** 3270 * ice_aq_get_recipe_to_profile - Map recipe to packet profile 3271 * @hw: pointer to the HW struct 3272 * @profile_id: package profile ID to associate the recipe with 3273 * @r_bitmap: Recipe bitmap filled in and need to be returned as response 3274 * @cd: pointer to command details structure or NULL 3275 * Associate profile ID with given recipe (0x0293) 3276 */ 3277 enum ice_status 3278 ice_aq_get_recipe_to_profile(struct ice_hw *hw, u32 profile_id, u8 *r_bitmap, 3279 struct ice_sq_cd *cd) 3280 { 3281 struct ice_aqc_recipe_to_profile *cmd; 3282 struct ice_aq_desc desc; 3283 enum ice_status status; 3284 3285 ice_debug(hw, ICE_DBG_TRACE, "%s\n", __func__); 3286 cmd = &desc.params.recipe_to_profile; 3287 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_recipe_to_profile); 3288 cmd->profile_id = CPU_TO_LE16(profile_id); 3289 3290 status = ice_aq_send_cmd(hw, &desc, NULL, 0, cd); 3291 if (!status) 3292 ice_memcpy(r_bitmap, cmd->recipe_assoc, 3293 sizeof(cmd->recipe_assoc), ICE_NONDMA_TO_NONDMA); 3294 3295 return status; 3296 } 3297 3298 /** 3299 * ice_alloc_recipe - add recipe resource 3300 * @hw: pointer to the hardware structure 3301 * @rid: recipe ID returned as response to AQ call 3302 */ 3303 enum ice_status ice_alloc_recipe(struct ice_hw *hw, u16 *rid) 3304 { 3305 struct ice_aqc_alloc_free_res_elem *sw_buf; 3306 enum ice_status status; 3307 u16 buf_len; 3308 3309 buf_len = ice_struct_size(sw_buf, elem, 1); 3310 sw_buf = (struct ice_aqc_alloc_free_res_elem *)ice_malloc(hw, buf_len); 3311 if (!sw_buf) 3312 return ICE_ERR_NO_MEMORY; 3313 3314 sw_buf->num_elems = CPU_TO_LE16(1); 3315 sw_buf->res_type = CPU_TO_LE16((ICE_AQC_RES_TYPE_RECIPE << 3316 ICE_AQC_RES_TYPE_S) | 3317 ICE_AQC_RES_TYPE_FLAG_SHARED); 3318 status = ice_aq_alloc_free_res(hw, 1, sw_buf, buf_len, 3319 ice_aqc_opc_alloc_res, NULL); 3320 if (!status) 3321 *rid = LE16_TO_CPU(sw_buf->elem[0].e.sw_resp); 3322 ice_free(hw, sw_buf); 3323 3324 return status; 3325 } 3326 3327 /* ice_init_port_info - Initialize port_info with switch configuration data 3328 * @pi: pointer to port_info 3329 * @vsi_port_num: VSI number or port number 3330 * @type: Type of switch element (port or VSI) 3331 * @swid: switch ID of the switch the element is attached to 3332 * @pf_vf_num: PF or VF number 3333 * @is_vf: true if the element is a VF, false otherwise 3334 */ 3335 static void 3336 ice_init_port_info(struct ice_port_info *pi, u16 vsi_port_num, u8 type, 3337 u16 swid, u16 pf_vf_num, bool is_vf) 3338 { 3339 switch (type) { 3340 case ICE_AQC_GET_SW_CONF_RESP_PHYS_PORT: 3341 pi->lport = (u8)(vsi_port_num & ICE_LPORT_MASK); 3342 pi->sw_id = swid; 3343 pi->pf_vf_num = pf_vf_num; 3344 pi->is_vf = is_vf; 3345 pi->dflt_tx_vsi_num = ICE_DFLT_VSI_INVAL; 3346 pi->dflt_rx_vsi_num = ICE_DFLT_VSI_INVAL; 3347 break; 3348 default: 3349 ice_debug(pi->hw, ICE_DBG_SW, "incorrect VSI/port type received\n"); 3350 break; 3351 } 3352 } 3353 3354 /* ice_get_initial_sw_cfg - Get initial port and default VSI data 3355 * @hw: pointer to the hardware structure 3356 */ 3357 enum ice_status ice_get_initial_sw_cfg(struct ice_hw *hw) 3358 { 3359 struct ice_aqc_get_sw_cfg_resp_elem *rbuf; 3360 enum ice_status status; 3361 u8 num_total_ports; 3362 u16 req_desc = 0; 3363 u16 num_elems; 3364 u8 j = 0; 3365 u16 i; 3366 3367 num_total_ports = 1; 3368 3369 rbuf = (struct ice_aqc_get_sw_cfg_resp_elem *) 3370 ice_malloc(hw, ICE_SW_CFG_MAX_BUF_LEN); 3371 3372 if (!rbuf) 3373 return ICE_ERR_NO_MEMORY; 3374 3375 /* Multiple calls to ice_aq_get_sw_cfg may be required 3376 * to get all the switch configuration information. The need 3377 * for additional calls is indicated by ice_aq_get_sw_cfg 3378 * writing a non-zero value in req_desc 3379 */ 3380 do { 3381 struct ice_aqc_get_sw_cfg_resp_elem *ele; 3382 3383 status = ice_aq_get_sw_cfg(hw, rbuf, ICE_SW_CFG_MAX_BUF_LEN, 3384 &req_desc, &num_elems, NULL); 3385 3386 if (status) 3387 break; 3388 3389 for (i = 0, ele = rbuf; i < num_elems; i++, ele++) { 3390 u16 pf_vf_num, swid, vsi_port_num; 3391 bool is_vf = false; 3392 u8 res_type; 3393 3394 vsi_port_num = LE16_TO_CPU(ele->vsi_port_num) & 3395 ICE_AQC_GET_SW_CONF_RESP_VSI_PORT_NUM_M; 3396 3397 pf_vf_num = LE16_TO_CPU(ele->pf_vf_num) & 3398 ICE_AQC_GET_SW_CONF_RESP_FUNC_NUM_M; 3399 3400 swid = LE16_TO_CPU(ele->swid); 3401 3402 if (LE16_TO_CPU(ele->pf_vf_num) & 3403 ICE_AQC_GET_SW_CONF_RESP_IS_VF) 3404 is_vf = true; 3405 3406 res_type = (u8)(LE16_TO_CPU(ele->vsi_port_num) >> 3407 ICE_AQC_GET_SW_CONF_RESP_TYPE_S); 3408 3409 switch (res_type) { 3410 case ICE_AQC_GET_SW_CONF_RESP_PHYS_PORT: 3411 case ICE_AQC_GET_SW_CONF_RESP_VIRT_PORT: 3412 if (j == num_total_ports) { 3413 ice_debug(hw, ICE_DBG_SW, "more ports than expected\n"); 3414 status = ICE_ERR_CFG; 3415 goto out; 3416 } 3417 ice_init_port_info(hw->port_info, 3418 vsi_port_num, res_type, swid, 3419 pf_vf_num, is_vf); 3420 j++; 3421 break; 3422 default: 3423 break; 3424 } 3425 } 3426 } while (req_desc && !status); 3427 3428 out: 3429 ice_free(hw, rbuf); 3430 return status; 3431 } 3432 3433 /** 3434 * ice_fill_sw_info - Helper function to populate lb_en and lan_en 3435 * @hw: pointer to the hardware structure 3436 * @fi: filter info structure to fill/update 3437 * 3438 * This helper function populates the lb_en and lan_en elements of the provided 3439 * ice_fltr_info struct using the switch's type and characteristics of the 3440 * switch rule being configured. 3441 */ 3442 static void ice_fill_sw_info(struct ice_hw *hw, struct ice_fltr_info *fi) 3443 { 3444 if ((fi->flag & ICE_FLTR_RX) && 3445 (fi->fltr_act == ICE_FWD_TO_VSI || 3446 fi->fltr_act == ICE_FWD_TO_VSI_LIST) && 3447 fi->lkup_type == ICE_SW_LKUP_LAST) 3448 fi->lan_en = true; 3449 fi->lb_en = false; 3450 fi->lan_en = false; 3451 if ((fi->flag & ICE_FLTR_TX) && 3452 (fi->fltr_act == ICE_FWD_TO_VSI || 3453 fi->fltr_act == ICE_FWD_TO_VSI_LIST || 3454 fi->fltr_act == ICE_FWD_TO_Q || 3455 fi->fltr_act == ICE_FWD_TO_QGRP)) { 3456 /* Setting LB for prune actions will result in replicated 3457 * packets to the internal switch that will be dropped. 3458 */ 3459 if (fi->lkup_type != ICE_SW_LKUP_VLAN) 3460 fi->lb_en = true; 3461 3462 /* Set lan_en to TRUE if 3463 * 1. The switch is a VEB AND 3464 * 2 3465 * 2.1 The lookup is a directional lookup like ethertype, 3466 * promiscuous, ethertype-MAC, promiscuous-VLAN 3467 * and default-port OR 3468 * 2.2 The lookup is VLAN, OR 3469 * 2.3 The lookup is MAC with mcast or bcast addr for MAC, OR 3470 * 2.4 The lookup is MAC_VLAN with mcast or bcast addr for MAC. 3471 * 3472 * OR 3473 * 3474 * The switch is a VEPA. 3475 * 3476 * In all other cases, the LAN enable has to be set to false. 3477 */ 3478 if (hw->evb_veb) { 3479 if (fi->lkup_type == ICE_SW_LKUP_ETHERTYPE || 3480 fi->lkup_type == ICE_SW_LKUP_PROMISC || 3481 fi->lkup_type == ICE_SW_LKUP_ETHERTYPE_MAC || 3482 fi->lkup_type == ICE_SW_LKUP_PROMISC_VLAN || 3483 fi->lkup_type == ICE_SW_LKUP_DFLT || 3484 fi->lkup_type == ICE_SW_LKUP_VLAN || 3485 (fi->lkup_type == ICE_SW_LKUP_MAC && 3486 !IS_UNICAST_ETHER_ADDR(fi->l_data.mac.mac_addr)) || 3487 (fi->lkup_type == ICE_SW_LKUP_MAC_VLAN && 3488 !IS_UNICAST_ETHER_ADDR(fi->l_data.mac.mac_addr))) 3489 fi->lan_en = true; 3490 } else { 3491 fi->lan_en = true; 3492 } 3493 } 3494 } 3495 3496 /** 3497 * ice_fill_sw_rule - Helper function to fill switch rule structure 3498 * @hw: pointer to the hardware structure 3499 * @f_info: entry containing packet forwarding information 3500 * @s_rule: switch rule structure to be filled in based on mac_entry 3501 * @opc: switch rules population command type - pass in the command opcode 3502 */ 3503 static void 3504 ice_fill_sw_rule(struct ice_hw *hw, struct ice_fltr_info *f_info, 3505 struct ice_aqc_sw_rules_elem *s_rule, enum ice_adminq_opc opc) 3506 { 3507 u16 vlan_id = ICE_MAX_VLAN_ID + 1; 3508 u16 vlan_tpid = ICE_ETH_P_8021Q; 3509 void *daddr = NULL; 3510 u16 eth_hdr_sz; 3511 u8 *eth_hdr; 3512 u32 act = 0; 3513 __be16 *off; 3514 u8 q_rgn; 3515 3516 if (opc == ice_aqc_opc_remove_sw_rules) { 3517 s_rule->pdata.lkup_tx_rx.act = 0; 3518 s_rule->pdata.lkup_tx_rx.index = 3519 CPU_TO_LE16(f_info->fltr_rule_id); 3520 s_rule->pdata.lkup_tx_rx.hdr_len = 0; 3521 return; 3522 } 3523 3524 eth_hdr_sz = sizeof(dummy_eth_header); 3525 eth_hdr = s_rule->pdata.lkup_tx_rx.hdr; 3526 3527 /* initialize the ether header with a dummy header */ 3528 ice_memcpy(eth_hdr, dummy_eth_header, eth_hdr_sz, ICE_NONDMA_TO_NONDMA); 3529 ice_fill_sw_info(hw, f_info); 3530 3531 switch (f_info->fltr_act) { 3532 case ICE_FWD_TO_VSI: 3533 act |= (f_info->fwd_id.hw_vsi_id << ICE_SINGLE_ACT_VSI_ID_S) & 3534 ICE_SINGLE_ACT_VSI_ID_M; 3535 if (f_info->lkup_type != ICE_SW_LKUP_VLAN) 3536 act |= ICE_SINGLE_ACT_VSI_FORWARDING | 3537 ICE_SINGLE_ACT_VALID_BIT; 3538 break; 3539 case ICE_FWD_TO_VSI_LIST: 3540 act |= ICE_SINGLE_ACT_VSI_LIST; 3541 act |= (f_info->fwd_id.vsi_list_id << 3542 ICE_SINGLE_ACT_VSI_LIST_ID_S) & 3543 ICE_SINGLE_ACT_VSI_LIST_ID_M; 3544 if (f_info->lkup_type != ICE_SW_LKUP_VLAN) 3545 act |= ICE_SINGLE_ACT_VSI_FORWARDING | 3546 ICE_SINGLE_ACT_VALID_BIT; 3547 break; 3548 case ICE_FWD_TO_Q: 3549 act |= ICE_SINGLE_ACT_TO_Q; 3550 act |= (f_info->fwd_id.q_id << ICE_SINGLE_ACT_Q_INDEX_S) & 3551 ICE_SINGLE_ACT_Q_INDEX_M; 3552 break; 3553 case ICE_DROP_PACKET: 3554 act |= ICE_SINGLE_ACT_VSI_FORWARDING | ICE_SINGLE_ACT_DROP | 3555 ICE_SINGLE_ACT_VALID_BIT; 3556 break; 3557 case ICE_FWD_TO_QGRP: 3558 q_rgn = f_info->qgrp_size > 0 ? 3559 (u8)ice_ilog2(f_info->qgrp_size) : 0; 3560 act |= ICE_SINGLE_ACT_TO_Q; 3561 act |= (f_info->fwd_id.q_id << ICE_SINGLE_ACT_Q_INDEX_S) & 3562 ICE_SINGLE_ACT_Q_INDEX_M; 3563 act |= (q_rgn << ICE_SINGLE_ACT_Q_REGION_S) & 3564 ICE_SINGLE_ACT_Q_REGION_M; 3565 break; 3566 default: 3567 return; 3568 } 3569 3570 if (f_info->lb_en) 3571 act |= ICE_SINGLE_ACT_LB_ENABLE; 3572 if (f_info->lan_en) 3573 act |= ICE_SINGLE_ACT_LAN_ENABLE; 3574 3575 switch (f_info->lkup_type) { 3576 case ICE_SW_LKUP_MAC: 3577 daddr = f_info->l_data.mac.mac_addr; 3578 break; 3579 case ICE_SW_LKUP_VLAN: 3580 vlan_id = f_info->l_data.vlan.vlan_id; 3581 if (f_info->l_data.vlan.tpid_valid) 3582 vlan_tpid = f_info->l_data.vlan.tpid; 3583 if (f_info->fltr_act == ICE_FWD_TO_VSI || 3584 f_info->fltr_act == ICE_FWD_TO_VSI_LIST) { 3585 act |= ICE_SINGLE_ACT_PRUNE; 3586 act |= ICE_SINGLE_ACT_EGRESS | ICE_SINGLE_ACT_INGRESS; 3587 } 3588 break; 3589 case ICE_SW_LKUP_ETHERTYPE_MAC: 3590 daddr = f_info->l_data.ethertype_mac.mac_addr; 3591 /* fall-through */ 3592 case ICE_SW_LKUP_ETHERTYPE: 3593 off = (_FORCE_ __be16 *)(eth_hdr + ICE_ETH_ETHTYPE_OFFSET); 3594 *off = CPU_TO_BE16(f_info->l_data.ethertype_mac.ethertype); 3595 break; 3596 case ICE_SW_LKUP_MAC_VLAN: 3597 daddr = f_info->l_data.mac_vlan.mac_addr; 3598 vlan_id = f_info->l_data.mac_vlan.vlan_id; 3599 break; 3600 case ICE_SW_LKUP_PROMISC_VLAN: 3601 vlan_id = f_info->l_data.mac_vlan.vlan_id; 3602 /* fall-through */ 3603 case ICE_SW_LKUP_PROMISC: 3604 daddr = f_info->l_data.mac_vlan.mac_addr; 3605 break; 3606 default: 3607 break; 3608 } 3609 3610 s_rule->type = (f_info->flag & ICE_FLTR_RX) ? 3611 CPU_TO_LE16(ICE_AQC_SW_RULES_T_LKUP_RX) : 3612 CPU_TO_LE16(ICE_AQC_SW_RULES_T_LKUP_TX); 3613 3614 /* Recipe set depending on lookup type */ 3615 s_rule->pdata.lkup_tx_rx.recipe_id = CPU_TO_LE16(f_info->lkup_type); 3616 s_rule->pdata.lkup_tx_rx.src = CPU_TO_LE16(f_info->src); 3617 s_rule->pdata.lkup_tx_rx.act = CPU_TO_LE32(act); 3618 3619 if (daddr) 3620 ice_memcpy(eth_hdr + ICE_ETH_DA_OFFSET, daddr, ETH_ALEN, 3621 ICE_NONDMA_TO_NONDMA); 3622 3623 if (!(vlan_id > ICE_MAX_VLAN_ID)) { 3624 off = (_FORCE_ __be16 *)(eth_hdr + ICE_ETH_VLAN_TCI_OFFSET); 3625 *off = CPU_TO_BE16(vlan_id); 3626 off = (_FORCE_ __be16 *)(eth_hdr + ICE_ETH_ETHTYPE_OFFSET); 3627 *off = CPU_TO_BE16(vlan_tpid); 3628 } 3629 3630 /* Create the switch rule with the final dummy Ethernet header */ 3631 if (opc != ice_aqc_opc_update_sw_rules) 3632 s_rule->pdata.lkup_tx_rx.hdr_len = CPU_TO_LE16(eth_hdr_sz); 3633 } 3634 3635 /** 3636 * ice_add_marker_act 3637 * @hw: pointer to the hardware structure 3638 * @m_ent: the management entry for which sw marker needs to be added 3639 * @sw_marker: sw marker to tag the Rx descriptor with 3640 * @l_id: large action resource ID 3641 * 3642 * Create a large action to hold software marker and update the switch rule 3643 * entry pointed by m_ent with newly created large action 3644 */ 3645 static enum ice_status 3646 ice_add_marker_act(struct ice_hw *hw, struct ice_fltr_mgmt_list_entry *m_ent, 3647 u16 sw_marker, u16 l_id) 3648 { 3649 struct ice_aqc_sw_rules_elem *lg_act, *rx_tx; 3650 /* For software marker we need 3 large actions 3651 * 1. FWD action: FWD TO VSI or VSI LIST 3652 * 2. GENERIC VALUE action to hold the profile ID 3653 * 3. GENERIC VALUE action to hold the software marker ID 3654 */ 3655 const u16 num_lg_acts = 3; 3656 enum ice_status status; 3657 u16 lg_act_size; 3658 u16 rules_size; 3659 u32 act; 3660 u16 id; 3661 3662 if (m_ent->fltr_info.lkup_type != ICE_SW_LKUP_MAC) 3663 return ICE_ERR_PARAM; 3664 3665 /* Create two back-to-back switch rules and submit them to the HW using 3666 * one memory buffer: 3667 * 1. Large Action 3668 * 2. Look up Tx Rx 3669 */ 3670 lg_act_size = (u16)ICE_SW_RULE_LG_ACT_SIZE(num_lg_acts); 3671 rules_size = lg_act_size + ICE_SW_RULE_RX_TX_ETH_HDR_SIZE; 3672 lg_act = (struct ice_aqc_sw_rules_elem *)ice_malloc(hw, rules_size); 3673 if (!lg_act) 3674 return ICE_ERR_NO_MEMORY; 3675 3676 rx_tx = (struct ice_aqc_sw_rules_elem *)((u8 *)lg_act + lg_act_size); 3677 3678 /* Fill in the first switch rule i.e. large action */ 3679 lg_act->type = CPU_TO_LE16(ICE_AQC_SW_RULES_T_LG_ACT); 3680 lg_act->pdata.lg_act.index = CPU_TO_LE16(l_id); 3681 lg_act->pdata.lg_act.size = CPU_TO_LE16(num_lg_acts); 3682 3683 /* First action VSI forwarding or VSI list forwarding depending on how 3684 * many VSIs 3685 */ 3686 id = (m_ent->vsi_count > 1) ? m_ent->fltr_info.fwd_id.vsi_list_id : 3687 m_ent->fltr_info.fwd_id.hw_vsi_id; 3688 3689 act = ICE_LG_ACT_VSI_FORWARDING | ICE_LG_ACT_VALID_BIT; 3690 act |= (id << ICE_LG_ACT_VSI_LIST_ID_S) & ICE_LG_ACT_VSI_LIST_ID_M; 3691 if (m_ent->vsi_count > 1) 3692 act |= ICE_LG_ACT_VSI_LIST; 3693 lg_act->pdata.lg_act.act[0] = CPU_TO_LE32(act); 3694 3695 /* Second action descriptor type */ 3696 act = ICE_LG_ACT_GENERIC; 3697 3698 act |= (1 << ICE_LG_ACT_GENERIC_VALUE_S) & ICE_LG_ACT_GENERIC_VALUE_M; 3699 lg_act->pdata.lg_act.act[1] = CPU_TO_LE32(act); 3700 3701 act = (ICE_LG_ACT_GENERIC_OFF_RX_DESC_PROF_IDX << 3702 ICE_LG_ACT_GENERIC_OFFSET_S) & ICE_LG_ACT_GENERIC_OFFSET_M; 3703 3704 /* Third action Marker value */ 3705 act |= ICE_LG_ACT_GENERIC; 3706 act |= (sw_marker << ICE_LG_ACT_GENERIC_VALUE_S) & 3707 ICE_LG_ACT_GENERIC_VALUE_M; 3708 3709 lg_act->pdata.lg_act.act[2] = CPU_TO_LE32(act); 3710 3711 /* call the fill switch rule to fill the lookup Tx Rx structure */ 3712 ice_fill_sw_rule(hw, &m_ent->fltr_info, rx_tx, 3713 ice_aqc_opc_update_sw_rules); 3714 3715 /* Update the action to point to the large action ID */ 3716 rx_tx->pdata.lkup_tx_rx.act = 3717 CPU_TO_LE32(ICE_SINGLE_ACT_PTR | 3718 ((l_id << ICE_SINGLE_ACT_PTR_VAL_S) & 3719 ICE_SINGLE_ACT_PTR_VAL_M)); 3720 3721 /* Use the filter rule ID of the previously created rule with single 3722 * act. Once the update happens, hardware will treat this as large 3723 * action 3724 */ 3725 rx_tx->pdata.lkup_tx_rx.index = 3726 CPU_TO_LE16(m_ent->fltr_info.fltr_rule_id); 3727 3728 status = ice_aq_sw_rules(hw, lg_act, rules_size, 2, 3729 ice_aqc_opc_update_sw_rules, NULL); 3730 if (!status) { 3731 m_ent->lg_act_idx = l_id; 3732 m_ent->sw_marker_id = sw_marker; 3733 } 3734 3735 ice_free(hw, lg_act); 3736 return status; 3737 } 3738 3739 /** 3740 * ice_add_counter_act - add/update filter rule with counter action 3741 * @hw: pointer to the hardware structure 3742 * @m_ent: the management entry for which counter needs to be added 3743 * @counter_id: VLAN counter ID returned as part of allocate resource 3744 * @l_id: large action resource ID 3745 */ 3746 static enum ice_status 3747 ice_add_counter_act(struct ice_hw *hw, struct ice_fltr_mgmt_list_entry *m_ent, 3748 u16 counter_id, u16 l_id) 3749 { 3750 struct ice_aqc_sw_rules_elem *lg_act; 3751 struct ice_aqc_sw_rules_elem *rx_tx; 3752 enum ice_status status; 3753 /* 2 actions will be added while adding a large action counter */ 3754 const int num_acts = 2; 3755 u16 lg_act_size; 3756 u16 rules_size; 3757 u16 f_rule_id; 3758 u32 act; 3759 u16 id; 3760 3761 if (m_ent->fltr_info.lkup_type != ICE_SW_LKUP_MAC) 3762 return ICE_ERR_PARAM; 3763 3764 /* Create two back-to-back switch rules and submit them to the HW using 3765 * one memory buffer: 3766 * 1. Large Action 3767 * 2. Look up Tx Rx 3768 */ 3769 lg_act_size = (u16)ICE_SW_RULE_LG_ACT_SIZE(num_acts); 3770 rules_size = lg_act_size + ICE_SW_RULE_RX_TX_ETH_HDR_SIZE; 3771 lg_act = (struct ice_aqc_sw_rules_elem *)ice_malloc(hw, rules_size); 3772 if (!lg_act) 3773 return ICE_ERR_NO_MEMORY; 3774 3775 rx_tx = (struct ice_aqc_sw_rules_elem *)((u8 *)lg_act + lg_act_size); 3776 3777 /* Fill in the first switch rule i.e. large action */ 3778 lg_act->type = CPU_TO_LE16(ICE_AQC_SW_RULES_T_LG_ACT); 3779 lg_act->pdata.lg_act.index = CPU_TO_LE16(l_id); 3780 lg_act->pdata.lg_act.size = CPU_TO_LE16(num_acts); 3781 3782 /* First action VSI forwarding or VSI list forwarding depending on how 3783 * many VSIs 3784 */ 3785 id = (m_ent->vsi_count > 1) ? m_ent->fltr_info.fwd_id.vsi_list_id : 3786 m_ent->fltr_info.fwd_id.hw_vsi_id; 3787 3788 act = ICE_LG_ACT_VSI_FORWARDING | ICE_LG_ACT_VALID_BIT; 3789 act |= (id << ICE_LG_ACT_VSI_LIST_ID_S) & 3790 ICE_LG_ACT_VSI_LIST_ID_M; 3791 if (m_ent->vsi_count > 1) 3792 act |= ICE_LG_ACT_VSI_LIST; 3793 lg_act->pdata.lg_act.act[0] = CPU_TO_LE32(act); 3794 3795 /* Second action counter ID */ 3796 act = ICE_LG_ACT_STAT_COUNT; 3797 act |= (counter_id << ICE_LG_ACT_STAT_COUNT_S) & 3798 ICE_LG_ACT_STAT_COUNT_M; 3799 lg_act->pdata.lg_act.act[1] = CPU_TO_LE32(act); 3800 3801 /* call the fill switch rule to fill the lookup Tx Rx structure */ 3802 ice_fill_sw_rule(hw, &m_ent->fltr_info, rx_tx, 3803 ice_aqc_opc_update_sw_rules); 3804 3805 act = ICE_SINGLE_ACT_PTR; 3806 act |= (l_id << ICE_SINGLE_ACT_PTR_VAL_S) & ICE_SINGLE_ACT_PTR_VAL_M; 3807 rx_tx->pdata.lkup_tx_rx.act = CPU_TO_LE32(act); 3808 3809 /* Use the filter rule ID of the previously created rule with single 3810 * act. Once the update happens, hardware will treat this as large 3811 * action 3812 */ 3813 f_rule_id = m_ent->fltr_info.fltr_rule_id; 3814 rx_tx->pdata.lkup_tx_rx.index = CPU_TO_LE16(f_rule_id); 3815 3816 status = ice_aq_sw_rules(hw, lg_act, rules_size, 2, 3817 ice_aqc_opc_update_sw_rules, NULL); 3818 if (!status) { 3819 m_ent->lg_act_idx = l_id; 3820 m_ent->counter_index = counter_id; 3821 } 3822 3823 ice_free(hw, lg_act); 3824 return status; 3825 } 3826 3827 /** 3828 * ice_create_vsi_list_map 3829 * @hw: pointer to the hardware structure 3830 * @vsi_handle_arr: array of VSI handles to set in the VSI mapping 3831 * @num_vsi: number of VSI handles in the array 3832 * @vsi_list_id: VSI list ID generated as part of allocate resource 3833 * 3834 * Helper function to create a new entry of VSI list ID to VSI mapping 3835 * using the given VSI list ID 3836 */ 3837 static struct ice_vsi_list_map_info * 3838 ice_create_vsi_list_map(struct ice_hw *hw, u16 *vsi_handle_arr, u16 num_vsi, 3839 u16 vsi_list_id) 3840 { 3841 struct ice_switch_info *sw = hw->switch_info; 3842 struct ice_vsi_list_map_info *v_map; 3843 int i; 3844 3845 v_map = (struct ice_vsi_list_map_info *)ice_malloc(hw, sizeof(*v_map)); 3846 if (!v_map) 3847 return NULL; 3848 3849 v_map->vsi_list_id = vsi_list_id; 3850 v_map->ref_cnt = 1; 3851 for (i = 0; i < num_vsi; i++) 3852 ice_set_bit(vsi_handle_arr[i], v_map->vsi_map); 3853 3854 LIST_ADD(&v_map->list_entry, &sw->vsi_list_map_head); 3855 return v_map; 3856 } 3857 3858 /** 3859 * ice_update_vsi_list_rule 3860 * @hw: pointer to the hardware structure 3861 * @vsi_handle_arr: array of VSI handles to form a VSI list 3862 * @num_vsi: number of VSI handles in the array 3863 * @vsi_list_id: VSI list ID generated as part of allocate resource 3864 * @remove: Boolean value to indicate if this is a remove action 3865 * @opc: switch rules population command type - pass in the command opcode 3866 * @lkup_type: lookup type of the filter 3867 * 3868 * Call AQ command to add a new switch rule or update existing switch rule 3869 * using the given VSI list ID 3870 */ 3871 static enum ice_status 3872 ice_update_vsi_list_rule(struct ice_hw *hw, u16 *vsi_handle_arr, u16 num_vsi, 3873 u16 vsi_list_id, bool remove, enum ice_adminq_opc opc, 3874 enum ice_sw_lkup_type lkup_type) 3875 { 3876 struct ice_aqc_sw_rules_elem *s_rule; 3877 enum ice_status status; 3878 u16 s_rule_size; 3879 u16 rule_type; 3880 int i; 3881 3882 if (!num_vsi) 3883 return ICE_ERR_PARAM; 3884 3885 if (lkup_type == ICE_SW_LKUP_MAC || 3886 lkup_type == ICE_SW_LKUP_MAC_VLAN || 3887 lkup_type == ICE_SW_LKUP_ETHERTYPE || 3888 lkup_type == ICE_SW_LKUP_ETHERTYPE_MAC || 3889 lkup_type == ICE_SW_LKUP_PROMISC || 3890 lkup_type == ICE_SW_LKUP_PROMISC_VLAN || 3891 lkup_type == ICE_SW_LKUP_LAST) 3892 rule_type = remove ? ICE_AQC_SW_RULES_T_VSI_LIST_CLEAR : 3893 ICE_AQC_SW_RULES_T_VSI_LIST_SET; 3894 else if (lkup_type == ICE_SW_LKUP_VLAN) 3895 rule_type = remove ? ICE_AQC_SW_RULES_T_PRUNE_LIST_CLEAR : 3896 ICE_AQC_SW_RULES_T_PRUNE_LIST_SET; 3897 else 3898 return ICE_ERR_PARAM; 3899 3900 s_rule_size = (u16)ICE_SW_RULE_VSI_LIST_SIZE(num_vsi); 3901 s_rule = (struct ice_aqc_sw_rules_elem *)ice_malloc(hw, s_rule_size); 3902 if (!s_rule) 3903 return ICE_ERR_NO_MEMORY; 3904 for (i = 0; i < num_vsi; i++) { 3905 if (!ice_is_vsi_valid(hw, vsi_handle_arr[i])) { 3906 status = ICE_ERR_PARAM; 3907 goto exit; 3908 } 3909 /* AQ call requires hw_vsi_id(s) */ 3910 s_rule->pdata.vsi_list.vsi[i] = 3911 CPU_TO_LE16(ice_get_hw_vsi_num(hw, vsi_handle_arr[i])); 3912 } 3913 3914 s_rule->type = CPU_TO_LE16(rule_type); 3915 s_rule->pdata.vsi_list.number_vsi = CPU_TO_LE16(num_vsi); 3916 s_rule->pdata.vsi_list.index = CPU_TO_LE16(vsi_list_id); 3917 3918 status = ice_aq_sw_rules(hw, s_rule, s_rule_size, 1, opc, NULL); 3919 3920 exit: 3921 ice_free(hw, s_rule); 3922 return status; 3923 } 3924 3925 /** 3926 * ice_create_vsi_list_rule - Creates and populates a VSI list rule 3927 * @hw: pointer to the HW struct 3928 * @vsi_handle_arr: array of VSI handles to form a VSI list 3929 * @num_vsi: number of VSI handles in the array 3930 * @vsi_list_id: stores the ID of the VSI list to be created 3931 * @lkup_type: switch rule filter's lookup type 3932 */ 3933 static enum ice_status 3934 ice_create_vsi_list_rule(struct ice_hw *hw, u16 *vsi_handle_arr, u16 num_vsi, 3935 u16 *vsi_list_id, enum ice_sw_lkup_type lkup_type) 3936 { 3937 enum ice_status status; 3938 3939 status = ice_aq_alloc_free_vsi_list(hw, vsi_list_id, lkup_type, 3940 ice_aqc_opc_alloc_res); 3941 if (status) 3942 return status; 3943 3944 /* Update the newly created VSI list to include the specified VSIs */ 3945 return ice_update_vsi_list_rule(hw, vsi_handle_arr, num_vsi, 3946 *vsi_list_id, false, 3947 ice_aqc_opc_add_sw_rules, lkup_type); 3948 } 3949 3950 /** 3951 * ice_create_pkt_fwd_rule 3952 * @hw: pointer to the hardware structure 3953 * @recp_list: corresponding filter management list 3954 * @f_entry: entry containing packet forwarding information 3955 * 3956 * Create switch rule with given filter information and add an entry 3957 * to the corresponding filter management list to track this switch rule 3958 * and VSI mapping 3959 */ 3960 static enum ice_status 3961 ice_create_pkt_fwd_rule(struct ice_hw *hw, struct ice_sw_recipe *recp_list, 3962 struct ice_fltr_list_entry *f_entry) 3963 { 3964 struct ice_fltr_mgmt_list_entry *fm_entry; 3965 struct ice_aqc_sw_rules_elem *s_rule; 3966 enum ice_status status; 3967 3968 s_rule = (struct ice_aqc_sw_rules_elem *) 3969 ice_malloc(hw, ICE_SW_RULE_RX_TX_ETH_HDR_SIZE); 3970 if (!s_rule) 3971 return ICE_ERR_NO_MEMORY; 3972 fm_entry = (struct ice_fltr_mgmt_list_entry *) 3973 ice_malloc(hw, sizeof(*fm_entry)); 3974 if (!fm_entry) { 3975 status = ICE_ERR_NO_MEMORY; 3976 goto ice_create_pkt_fwd_rule_exit; 3977 } 3978 3979 fm_entry->fltr_info = f_entry->fltr_info; 3980 3981 /* Initialize all the fields for the management entry */ 3982 fm_entry->vsi_count = 1; 3983 fm_entry->lg_act_idx = ICE_INVAL_LG_ACT_INDEX; 3984 fm_entry->sw_marker_id = ICE_INVAL_SW_MARKER_ID; 3985 fm_entry->counter_index = ICE_INVAL_COUNTER_ID; 3986 3987 ice_fill_sw_rule(hw, &fm_entry->fltr_info, s_rule, 3988 ice_aqc_opc_add_sw_rules); 3989 3990 status = ice_aq_sw_rules(hw, s_rule, ICE_SW_RULE_RX_TX_ETH_HDR_SIZE, 1, 3991 ice_aqc_opc_add_sw_rules, NULL); 3992 if (status) { 3993 ice_free(hw, fm_entry); 3994 goto ice_create_pkt_fwd_rule_exit; 3995 } 3996 3997 f_entry->fltr_info.fltr_rule_id = 3998 LE16_TO_CPU(s_rule->pdata.lkup_tx_rx.index); 3999 fm_entry->fltr_info.fltr_rule_id = 4000 LE16_TO_CPU(s_rule->pdata.lkup_tx_rx.index); 4001 4002 /* The book keeping entries will get removed when base driver 4003 * calls remove filter AQ command 4004 */ 4005 LIST_ADD(&fm_entry->list_entry, &recp_list->filt_rules); 4006 4007 ice_create_pkt_fwd_rule_exit: 4008 ice_free(hw, s_rule); 4009 return status; 4010 } 4011 4012 /** 4013 * ice_update_pkt_fwd_rule 4014 * @hw: pointer to the hardware structure 4015 * @f_info: filter information for switch rule 4016 * 4017 * Call AQ command to update a previously created switch rule with a 4018 * VSI list ID 4019 */ 4020 static enum ice_status 4021 ice_update_pkt_fwd_rule(struct ice_hw *hw, struct ice_fltr_info *f_info) 4022 { 4023 struct ice_aqc_sw_rules_elem *s_rule; 4024 enum ice_status status; 4025 4026 s_rule = (struct ice_aqc_sw_rules_elem *) 4027 ice_malloc(hw, ICE_SW_RULE_RX_TX_ETH_HDR_SIZE); 4028 if (!s_rule) 4029 return ICE_ERR_NO_MEMORY; 4030 4031 ice_fill_sw_rule(hw, f_info, s_rule, ice_aqc_opc_update_sw_rules); 4032 4033 s_rule->pdata.lkup_tx_rx.index = CPU_TO_LE16(f_info->fltr_rule_id); 4034 4035 /* Update switch rule with new rule set to forward VSI list */ 4036 status = ice_aq_sw_rules(hw, s_rule, ICE_SW_RULE_RX_TX_ETH_HDR_SIZE, 1, 4037 ice_aqc_opc_update_sw_rules, NULL); 4038 4039 ice_free(hw, s_rule); 4040 return status; 4041 } 4042 4043 /** 4044 * ice_update_sw_rule_bridge_mode 4045 * @hw: pointer to the HW struct 4046 * 4047 * Updates unicast switch filter rules based on VEB/VEPA mode 4048 */ 4049 enum ice_status ice_update_sw_rule_bridge_mode(struct ice_hw *hw) 4050 { 4051 struct ice_switch_info *sw = hw->switch_info; 4052 struct ice_fltr_mgmt_list_entry *fm_entry; 4053 enum ice_status status = ICE_SUCCESS; 4054 struct LIST_HEAD_TYPE *rule_head; 4055 struct ice_lock *rule_lock; /* Lock to protect filter rule list */ 4056 4057 rule_lock = &sw->recp_list[ICE_SW_LKUP_MAC].filt_rule_lock; 4058 rule_head = &sw->recp_list[ICE_SW_LKUP_MAC].filt_rules; 4059 4060 ice_acquire_lock(rule_lock); 4061 LIST_FOR_EACH_ENTRY(fm_entry, rule_head, ice_fltr_mgmt_list_entry, 4062 list_entry) { 4063 struct ice_fltr_info *fi = &fm_entry->fltr_info; 4064 u8 *addr = fi->l_data.mac.mac_addr; 4065 4066 /* Update unicast Tx rules to reflect the selected 4067 * VEB/VEPA mode 4068 */ 4069 if ((fi->flag & ICE_FLTR_TX) && IS_UNICAST_ETHER_ADDR(addr) && 4070 (fi->fltr_act == ICE_FWD_TO_VSI || 4071 fi->fltr_act == ICE_FWD_TO_VSI_LIST || 4072 fi->fltr_act == ICE_FWD_TO_Q || 4073 fi->fltr_act == ICE_FWD_TO_QGRP)) { 4074 status = ice_update_pkt_fwd_rule(hw, fi); 4075 if (status) 4076 break; 4077 } 4078 } 4079 4080 ice_release_lock(rule_lock); 4081 4082 return status; 4083 } 4084 4085 /** 4086 * ice_add_update_vsi_list 4087 * @hw: pointer to the hardware structure 4088 * @m_entry: pointer to current filter management list entry 4089 * @cur_fltr: filter information from the book keeping entry 4090 * @new_fltr: filter information with the new VSI to be added 4091 * 4092 * Call AQ command to add or update previously created VSI list with new VSI. 4093 * 4094 * Helper function to do book keeping associated with adding filter information 4095 * The algorithm to do the book keeping is described below : 4096 * When a VSI needs to subscribe to a given filter (MAC/VLAN/Ethtype etc.) 4097 * if only one VSI has been added till now 4098 * Allocate a new VSI list and add two VSIs 4099 * to this list using switch rule command 4100 * Update the previously created switch rule with the 4101 * newly created VSI list ID 4102 * if a VSI list was previously created 4103 * Add the new VSI to the previously created VSI list set 4104 * using the update switch rule command 4105 */ 4106 static enum ice_status 4107 ice_add_update_vsi_list(struct ice_hw *hw, 4108 struct ice_fltr_mgmt_list_entry *m_entry, 4109 struct ice_fltr_info *cur_fltr, 4110 struct ice_fltr_info *new_fltr) 4111 { 4112 enum ice_status status = ICE_SUCCESS; 4113 u16 vsi_list_id = 0; 4114 4115 if ((cur_fltr->fltr_act == ICE_FWD_TO_Q || 4116 cur_fltr->fltr_act == ICE_FWD_TO_QGRP)) 4117 return ICE_ERR_NOT_IMPL; 4118 4119 if ((new_fltr->fltr_act == ICE_FWD_TO_Q || 4120 new_fltr->fltr_act == ICE_FWD_TO_QGRP) && 4121 (cur_fltr->fltr_act == ICE_FWD_TO_VSI || 4122 cur_fltr->fltr_act == ICE_FWD_TO_VSI_LIST)) 4123 return ICE_ERR_NOT_IMPL; 4124 4125 if (m_entry->vsi_count < 2 && !m_entry->vsi_list_info) { 4126 /* Only one entry existed in the mapping and it was not already 4127 * a part of a VSI list. So, create a VSI list with the old and 4128 * new VSIs. 4129 */ 4130 struct ice_fltr_info tmp_fltr; 4131 u16 vsi_handle_arr[2]; 4132 4133 /* A rule already exists with the new VSI being added */ 4134 if (cur_fltr->fwd_id.hw_vsi_id == new_fltr->fwd_id.hw_vsi_id) 4135 return ICE_ERR_ALREADY_EXISTS; 4136 4137 vsi_handle_arr[0] = cur_fltr->vsi_handle; 4138 vsi_handle_arr[1] = new_fltr->vsi_handle; 4139 status = ice_create_vsi_list_rule(hw, &vsi_handle_arr[0], 2, 4140 &vsi_list_id, 4141 new_fltr->lkup_type); 4142 if (status) 4143 return status; 4144 4145 tmp_fltr = *new_fltr; 4146 tmp_fltr.fltr_rule_id = cur_fltr->fltr_rule_id; 4147 tmp_fltr.fltr_act = ICE_FWD_TO_VSI_LIST; 4148 tmp_fltr.fwd_id.vsi_list_id = vsi_list_id; 4149 /* Update the previous switch rule of "MAC forward to VSI" to 4150 * "MAC fwd to VSI list" 4151 */ 4152 status = ice_update_pkt_fwd_rule(hw, &tmp_fltr); 4153 if (status) 4154 return status; 4155 4156 cur_fltr->fwd_id.vsi_list_id = vsi_list_id; 4157 cur_fltr->fltr_act = ICE_FWD_TO_VSI_LIST; 4158 m_entry->vsi_list_info = 4159 ice_create_vsi_list_map(hw, &vsi_handle_arr[0], 2, 4160 vsi_list_id); 4161 4162 if (!m_entry->vsi_list_info) 4163 return ICE_ERR_NO_MEMORY; 4164 4165 /* If this entry was large action then the large action needs 4166 * to be updated to point to FWD to VSI list 4167 */ 4168 if (m_entry->sw_marker_id != ICE_INVAL_SW_MARKER_ID) 4169 status = 4170 ice_add_marker_act(hw, m_entry, 4171 m_entry->sw_marker_id, 4172 m_entry->lg_act_idx); 4173 } else { 4174 u16 vsi_handle = new_fltr->vsi_handle; 4175 enum ice_adminq_opc opcode; 4176 4177 if (!m_entry->vsi_list_info) 4178 return ICE_ERR_CFG; 4179 4180 /* A rule already exists with the new VSI being added */ 4181 if (ice_is_bit_set(m_entry->vsi_list_info->vsi_map, vsi_handle)) 4182 return ICE_SUCCESS; 4183 4184 /* Update the previously created VSI list set with 4185 * the new VSI ID passed in 4186 */ 4187 vsi_list_id = cur_fltr->fwd_id.vsi_list_id; 4188 opcode = ice_aqc_opc_update_sw_rules; 4189 4190 status = ice_update_vsi_list_rule(hw, &vsi_handle, 1, 4191 vsi_list_id, false, opcode, 4192 new_fltr->lkup_type); 4193 /* update VSI list mapping info with new VSI ID */ 4194 if (!status) 4195 ice_set_bit(vsi_handle, 4196 m_entry->vsi_list_info->vsi_map); 4197 } 4198 if (!status) 4199 m_entry->vsi_count++; 4200 return status; 4201 } 4202 4203 /** 4204 * ice_find_rule_entry - Search a rule entry 4205 * @list_head: head of rule list 4206 * @f_info: rule information 4207 * 4208 * Helper function to search for a given rule entry 4209 * Returns pointer to entry storing the rule if found 4210 */ 4211 static struct ice_fltr_mgmt_list_entry * 4212 ice_find_rule_entry(struct LIST_HEAD_TYPE *list_head, 4213 struct ice_fltr_info *f_info) 4214 { 4215 struct ice_fltr_mgmt_list_entry *list_itr, *ret = NULL; 4216 4217 LIST_FOR_EACH_ENTRY(list_itr, list_head, ice_fltr_mgmt_list_entry, 4218 list_entry) { 4219 if (!memcmp(&f_info->l_data, &list_itr->fltr_info.l_data, 4220 sizeof(f_info->l_data)) && 4221 f_info->flag == list_itr->fltr_info.flag) { 4222 ret = list_itr; 4223 break; 4224 } 4225 } 4226 return ret; 4227 } 4228 4229 /** 4230 * ice_find_vsi_list_entry - Search VSI list map with VSI count 1 4231 * @recp_list: VSI lists needs to be searched 4232 * @vsi_handle: VSI handle to be found in VSI list 4233 * @vsi_list_id: VSI list ID found containing vsi_handle 4234 * 4235 * Helper function to search a VSI list with single entry containing given VSI 4236 * handle element. This can be extended further to search VSI list with more 4237 * than 1 vsi_count. Returns pointer to VSI list entry if found. 4238 */ 4239 static struct ice_vsi_list_map_info * 4240 ice_find_vsi_list_entry(struct ice_sw_recipe *recp_list, u16 vsi_handle, 4241 u16 *vsi_list_id) 4242 { 4243 struct ice_vsi_list_map_info *map_info = NULL; 4244 struct LIST_HEAD_TYPE *list_head; 4245 4246 list_head = &recp_list->filt_rules; 4247 if (recp_list->adv_rule) { 4248 struct ice_adv_fltr_mgmt_list_entry *list_itr; 4249 4250 LIST_FOR_EACH_ENTRY(list_itr, list_head, 4251 ice_adv_fltr_mgmt_list_entry, 4252 list_entry) { 4253 if (list_itr->vsi_list_info) { 4254 map_info = list_itr->vsi_list_info; 4255 if (ice_is_bit_set(map_info->vsi_map, 4256 vsi_handle)) { 4257 *vsi_list_id = map_info->vsi_list_id; 4258 return map_info; 4259 } 4260 } 4261 } 4262 } else { 4263 struct ice_fltr_mgmt_list_entry *list_itr; 4264 4265 LIST_FOR_EACH_ENTRY(list_itr, list_head, 4266 ice_fltr_mgmt_list_entry, 4267 list_entry) { 4268 if (list_itr->vsi_count == 1 && 4269 list_itr->vsi_list_info) { 4270 map_info = list_itr->vsi_list_info; 4271 if (ice_is_bit_set(map_info->vsi_map, 4272 vsi_handle)) { 4273 *vsi_list_id = map_info->vsi_list_id; 4274 return map_info; 4275 } 4276 } 4277 } 4278 } 4279 return NULL; 4280 } 4281 4282 /** 4283 * ice_add_rule_internal - add rule for a given lookup type 4284 * @hw: pointer to the hardware structure 4285 * @recp_list: recipe list for which rule has to be added 4286 * @lport: logic port number on which function add rule 4287 * @f_entry: structure containing MAC forwarding information 4288 * 4289 * Adds or updates the rule lists for a given recipe 4290 */ 4291 static enum ice_status 4292 ice_add_rule_internal(struct ice_hw *hw, struct ice_sw_recipe *recp_list, 4293 u8 lport, struct ice_fltr_list_entry *f_entry) 4294 { 4295 struct ice_fltr_info *new_fltr, *cur_fltr; 4296 struct ice_fltr_mgmt_list_entry *m_entry; 4297 struct ice_lock *rule_lock; /* Lock to protect filter rule list */ 4298 enum ice_status status = ICE_SUCCESS; 4299 4300 if (!ice_is_vsi_valid(hw, f_entry->fltr_info.vsi_handle)) 4301 return ICE_ERR_PARAM; 4302 4303 /* Load the hw_vsi_id only if the fwd action is fwd to VSI */ 4304 if (f_entry->fltr_info.fltr_act == ICE_FWD_TO_VSI) 4305 f_entry->fltr_info.fwd_id.hw_vsi_id = 4306 ice_get_hw_vsi_num(hw, f_entry->fltr_info.vsi_handle); 4307 4308 rule_lock = &recp_list->filt_rule_lock; 4309 4310 ice_acquire_lock(rule_lock); 4311 new_fltr = &f_entry->fltr_info; 4312 if (new_fltr->flag & ICE_FLTR_RX) 4313 new_fltr->src = lport; 4314 else if (new_fltr->flag & ICE_FLTR_TX) 4315 new_fltr->src = 4316 ice_get_hw_vsi_num(hw, f_entry->fltr_info.vsi_handle); 4317 4318 m_entry = ice_find_rule_entry(&recp_list->filt_rules, new_fltr); 4319 if (!m_entry) { 4320 status = ice_create_pkt_fwd_rule(hw, recp_list, f_entry); 4321 goto exit_add_rule_internal; 4322 } 4323 4324 cur_fltr = &m_entry->fltr_info; 4325 status = ice_add_update_vsi_list(hw, m_entry, cur_fltr, new_fltr); 4326 4327 exit_add_rule_internal: 4328 ice_release_lock(rule_lock); 4329 return status; 4330 } 4331 4332 /** 4333 * ice_remove_vsi_list_rule 4334 * @hw: pointer to the hardware structure 4335 * @vsi_list_id: VSI list ID generated as part of allocate resource 4336 * @lkup_type: switch rule filter lookup type 4337 * 4338 * The VSI list should be emptied before this function is called to remove the 4339 * VSI list. 4340 */ 4341 static enum ice_status 4342 ice_remove_vsi_list_rule(struct ice_hw *hw, u16 vsi_list_id, 4343 enum ice_sw_lkup_type lkup_type) 4344 { 4345 /* Free the vsi_list resource that we allocated. It is assumed that the 4346 * list is empty at this point. 4347 */ 4348 return ice_aq_alloc_free_vsi_list(hw, &vsi_list_id, lkup_type, 4349 ice_aqc_opc_free_res); 4350 } 4351 4352 /** 4353 * ice_rem_update_vsi_list 4354 * @hw: pointer to the hardware structure 4355 * @vsi_handle: VSI handle of the VSI to remove 4356 * @fm_list: filter management entry for which the VSI list management needs to 4357 * be done 4358 */ 4359 static enum ice_status 4360 ice_rem_update_vsi_list(struct ice_hw *hw, u16 vsi_handle, 4361 struct ice_fltr_mgmt_list_entry *fm_list) 4362 { 4363 enum ice_sw_lkup_type lkup_type; 4364 enum ice_status status = ICE_SUCCESS; 4365 u16 vsi_list_id; 4366 4367 if (fm_list->fltr_info.fltr_act != ICE_FWD_TO_VSI_LIST || 4368 fm_list->vsi_count == 0) 4369 return ICE_ERR_PARAM; 4370 4371 /* A rule with the VSI being removed does not exist */ 4372 if (!ice_is_bit_set(fm_list->vsi_list_info->vsi_map, vsi_handle)) 4373 return ICE_ERR_DOES_NOT_EXIST; 4374 4375 lkup_type = fm_list->fltr_info.lkup_type; 4376 vsi_list_id = fm_list->fltr_info.fwd_id.vsi_list_id; 4377 status = ice_update_vsi_list_rule(hw, &vsi_handle, 1, vsi_list_id, true, 4378 ice_aqc_opc_update_sw_rules, 4379 lkup_type); 4380 if (status) 4381 return status; 4382 4383 fm_list->vsi_count--; 4384 ice_clear_bit(vsi_handle, fm_list->vsi_list_info->vsi_map); 4385 4386 if (fm_list->vsi_count == 1 && lkup_type != ICE_SW_LKUP_VLAN) { 4387 struct ice_fltr_info tmp_fltr_info = fm_list->fltr_info; 4388 struct ice_vsi_list_map_info *vsi_list_info = 4389 fm_list->vsi_list_info; 4390 u16 rem_vsi_handle; 4391 4392 rem_vsi_handle = ice_find_first_bit(vsi_list_info->vsi_map, 4393 ICE_MAX_VSI); 4394 if (!ice_is_vsi_valid(hw, rem_vsi_handle)) 4395 return ICE_ERR_OUT_OF_RANGE; 4396 4397 /* Make sure VSI list is empty before removing it below */ 4398 status = ice_update_vsi_list_rule(hw, &rem_vsi_handle, 1, 4399 vsi_list_id, true, 4400 ice_aqc_opc_update_sw_rules, 4401 lkup_type); 4402 if (status) 4403 return status; 4404 4405 tmp_fltr_info.fltr_act = ICE_FWD_TO_VSI; 4406 tmp_fltr_info.fwd_id.hw_vsi_id = 4407 ice_get_hw_vsi_num(hw, rem_vsi_handle); 4408 tmp_fltr_info.vsi_handle = rem_vsi_handle; 4409 status = ice_update_pkt_fwd_rule(hw, &tmp_fltr_info); 4410 if (status) { 4411 ice_debug(hw, ICE_DBG_SW, "Failed to update pkt fwd rule to FWD_TO_VSI on HW VSI %d, error %d\n", 4412 tmp_fltr_info.fwd_id.hw_vsi_id, status); 4413 return status; 4414 } 4415 4416 fm_list->fltr_info = tmp_fltr_info; 4417 } 4418 4419 if ((fm_list->vsi_count == 1 && lkup_type != ICE_SW_LKUP_VLAN) || 4420 (fm_list->vsi_count == 0 && lkup_type == ICE_SW_LKUP_VLAN)) { 4421 struct ice_vsi_list_map_info *vsi_list_info = 4422 fm_list->vsi_list_info; 4423 4424 /* Remove the VSI list since it is no longer used */ 4425 status = ice_remove_vsi_list_rule(hw, vsi_list_id, lkup_type); 4426 if (status) { 4427 ice_debug(hw, ICE_DBG_SW, "Failed to remove VSI list %d, error %d\n", 4428 vsi_list_id, status); 4429 return status; 4430 } 4431 4432 LIST_DEL(&vsi_list_info->list_entry); 4433 ice_free(hw, vsi_list_info); 4434 fm_list->vsi_list_info = NULL; 4435 } 4436 4437 return status; 4438 } 4439 4440 /** 4441 * ice_remove_rule_internal - Remove a filter rule of a given type 4442 * 4443 * @hw: pointer to the hardware structure 4444 * @recp_list: recipe list for which the rule needs to removed 4445 * @f_entry: rule entry containing filter information 4446 */ 4447 static enum ice_status 4448 ice_remove_rule_internal(struct ice_hw *hw, struct ice_sw_recipe *recp_list, 4449 struct ice_fltr_list_entry *f_entry) 4450 { 4451 struct ice_fltr_mgmt_list_entry *list_elem; 4452 struct ice_lock *rule_lock; /* Lock to protect filter rule list */ 4453 enum ice_status status = ICE_SUCCESS; 4454 bool remove_rule = false; 4455 u16 vsi_handle; 4456 4457 if (!ice_is_vsi_valid(hw, f_entry->fltr_info.vsi_handle)) 4458 return ICE_ERR_PARAM; 4459 f_entry->fltr_info.fwd_id.hw_vsi_id = 4460 ice_get_hw_vsi_num(hw, f_entry->fltr_info.vsi_handle); 4461 4462 rule_lock = &recp_list->filt_rule_lock; 4463 ice_acquire_lock(rule_lock); 4464 list_elem = ice_find_rule_entry(&recp_list->filt_rules, 4465 &f_entry->fltr_info); 4466 if (!list_elem) { 4467 status = ICE_ERR_DOES_NOT_EXIST; 4468 goto exit; 4469 } 4470 4471 if (list_elem->fltr_info.fltr_act != ICE_FWD_TO_VSI_LIST) { 4472 remove_rule = true; 4473 } else if (!list_elem->vsi_list_info) { 4474 status = ICE_ERR_DOES_NOT_EXIST; 4475 goto exit; 4476 } else if (list_elem->vsi_list_info->ref_cnt > 1) { 4477 /* a ref_cnt > 1 indicates that the vsi_list is being 4478 * shared by multiple rules. Decrement the ref_cnt and 4479 * remove this rule, but do not modify the list, as it 4480 * is in-use by other rules. 4481 */ 4482 list_elem->vsi_list_info->ref_cnt--; 4483 remove_rule = true; 4484 } else { 4485 /* a ref_cnt of 1 indicates the vsi_list is only used 4486 * by one rule. However, the original removal request is only 4487 * for a single VSI. Update the vsi_list first, and only 4488 * remove the rule if there are no further VSIs in this list. 4489 */ 4490 vsi_handle = f_entry->fltr_info.vsi_handle; 4491 status = ice_rem_update_vsi_list(hw, vsi_handle, list_elem); 4492 if (status) 4493 goto exit; 4494 /* if VSI count goes to zero after updating the VSI list */ 4495 if (list_elem->vsi_count == 0) 4496 remove_rule = true; 4497 } 4498 4499 if (remove_rule) { 4500 /* Remove the lookup rule */ 4501 struct ice_aqc_sw_rules_elem *s_rule; 4502 4503 s_rule = (struct ice_aqc_sw_rules_elem *) 4504 ice_malloc(hw, ICE_SW_RULE_RX_TX_NO_HDR_SIZE); 4505 if (!s_rule) { 4506 status = ICE_ERR_NO_MEMORY; 4507 goto exit; 4508 } 4509 4510 ice_fill_sw_rule(hw, &list_elem->fltr_info, s_rule, 4511 ice_aqc_opc_remove_sw_rules); 4512 4513 status = ice_aq_sw_rules(hw, s_rule, 4514 ICE_SW_RULE_RX_TX_NO_HDR_SIZE, 1, 4515 ice_aqc_opc_remove_sw_rules, NULL); 4516 4517 /* Remove a book keeping from the list */ 4518 ice_free(hw, s_rule); 4519 4520 if (status) 4521 goto exit; 4522 4523 LIST_DEL(&list_elem->list_entry); 4524 ice_free(hw, list_elem); 4525 } 4526 exit: 4527 ice_release_lock(rule_lock); 4528 return status; 4529 } 4530 4531 /** 4532 * ice_aq_get_res_alloc - get allocated resources 4533 * @hw: pointer to the HW struct 4534 * @num_entries: pointer to u16 to store the number of resource entries returned 4535 * @buf: pointer to buffer 4536 * @buf_size: size of buf 4537 * @cd: pointer to command details structure or NULL 4538 * 4539 * The caller-supplied buffer must be large enough to store the resource 4540 * information for all resource types. Each resource type is an 4541 * ice_aqc_get_res_resp_elem structure. 4542 */ 4543 enum ice_status 4544 ice_aq_get_res_alloc(struct ice_hw *hw, u16 *num_entries, 4545 struct ice_aqc_get_res_resp_elem *buf, u16 buf_size, 4546 struct ice_sq_cd *cd) 4547 { 4548 struct ice_aqc_get_res_alloc *resp; 4549 enum ice_status status; 4550 struct ice_aq_desc desc; 4551 4552 if (!buf) 4553 return ICE_ERR_BAD_PTR; 4554 4555 if (buf_size < ICE_AQ_GET_RES_ALLOC_BUF_LEN) 4556 return ICE_ERR_INVAL_SIZE; 4557 4558 resp = &desc.params.get_res; 4559 4560 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_res_alloc); 4561 status = ice_aq_send_cmd(hw, &desc, buf, buf_size, cd); 4562 4563 if (!status && num_entries) 4564 *num_entries = LE16_TO_CPU(resp->resp_elem_num); 4565 4566 return status; 4567 } 4568 4569 /** 4570 * ice_aq_get_res_descs - get allocated resource descriptors 4571 * @hw: pointer to the hardware structure 4572 * @num_entries: number of resource entries in buffer 4573 * @buf: structure to hold response data buffer 4574 * @buf_size: size of buffer 4575 * @res_type: resource type 4576 * @res_shared: is resource shared 4577 * @desc_id: input - first desc ID to start; output - next desc ID 4578 * @cd: pointer to command details structure or NULL 4579 */ 4580 enum ice_status 4581 ice_aq_get_res_descs(struct ice_hw *hw, u16 num_entries, 4582 struct ice_aqc_res_elem *buf, u16 buf_size, u16 res_type, 4583 bool res_shared, u16 *desc_id, struct ice_sq_cd *cd) 4584 { 4585 struct ice_aqc_get_allocd_res_desc *cmd; 4586 struct ice_aq_desc desc; 4587 enum ice_status status; 4588 4589 ice_debug(hw, ICE_DBG_TRACE, "%s\n", __func__); 4590 4591 cmd = &desc.params.get_res_desc; 4592 4593 if (!buf) 4594 return ICE_ERR_PARAM; 4595 4596 if (buf_size != (num_entries * sizeof(*buf))) 4597 return ICE_ERR_PARAM; 4598 4599 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_allocd_res_desc); 4600 4601 cmd->ops.cmd.res = CPU_TO_LE16(((res_type << ICE_AQC_RES_TYPE_S) & 4602 ICE_AQC_RES_TYPE_M) | (res_shared ? 4603 ICE_AQC_RES_TYPE_FLAG_SHARED : 0)); 4604 cmd->ops.cmd.first_desc = CPU_TO_LE16(*desc_id); 4605 4606 status = ice_aq_send_cmd(hw, &desc, buf, buf_size, cd); 4607 if (!status) 4608 *desc_id = LE16_TO_CPU(cmd->ops.resp.next_desc); 4609 4610 return status; 4611 } 4612 4613 /** 4614 * ice_add_mac_rule - Add a MAC address based filter rule 4615 * @hw: pointer to the hardware structure 4616 * @m_list: list of MAC addresses and forwarding information 4617 * @sw: pointer to switch info struct for which function add rule 4618 * @lport: logic port number on which function add rule 4619 * 4620 * IMPORTANT: When the ucast_shared flag is set to false and m_list has 4621 * multiple unicast addresses, the function assumes that all the 4622 * addresses are unique in a given add_mac call. It doesn't 4623 * check for duplicates in this case, removing duplicates from a given 4624 * list should be taken care of in the caller of this function. 4625 */ 4626 static enum ice_status 4627 ice_add_mac_rule(struct ice_hw *hw, struct LIST_HEAD_TYPE *m_list, 4628 struct ice_switch_info *sw, u8 lport) 4629 { 4630 struct ice_sw_recipe *recp_list = &sw->recp_list[ICE_SW_LKUP_MAC]; 4631 struct ice_aqc_sw_rules_elem *s_rule, *r_iter; 4632 struct ice_fltr_list_entry *m_list_itr; 4633 struct LIST_HEAD_TYPE *rule_head; 4634 u16 total_elem_left, s_rule_size; 4635 struct ice_lock *rule_lock; /* Lock to protect filter rule list */ 4636 enum ice_status status = ICE_SUCCESS; 4637 u16 num_unicast = 0; 4638 u8 elem_sent; 4639 4640 s_rule = NULL; 4641 rule_lock = &recp_list->filt_rule_lock; 4642 rule_head = &recp_list->filt_rules; 4643 4644 LIST_FOR_EACH_ENTRY(m_list_itr, m_list, ice_fltr_list_entry, 4645 list_entry) { 4646 u8 *add = &m_list_itr->fltr_info.l_data.mac.mac_addr[0]; 4647 u16 vsi_handle; 4648 u16 hw_vsi_id; 4649 4650 m_list_itr->fltr_info.flag = ICE_FLTR_TX; 4651 vsi_handle = m_list_itr->fltr_info.vsi_handle; 4652 if (!ice_is_vsi_valid(hw, vsi_handle)) 4653 return ICE_ERR_PARAM; 4654 hw_vsi_id = ice_get_hw_vsi_num(hw, vsi_handle); 4655 m_list_itr->fltr_info.fwd_id.hw_vsi_id = hw_vsi_id; 4656 /* update the src in case it is VSI num */ 4657 if (m_list_itr->fltr_info.src_id != ICE_SRC_ID_VSI) 4658 return ICE_ERR_PARAM; 4659 m_list_itr->fltr_info.src = hw_vsi_id; 4660 if (m_list_itr->fltr_info.lkup_type != ICE_SW_LKUP_MAC || 4661 IS_ZERO_ETHER_ADDR(add)) 4662 return ICE_ERR_PARAM; 4663 if (IS_UNICAST_ETHER_ADDR(add) && !hw->ucast_shared) { 4664 /* Don't overwrite the unicast address */ 4665 ice_acquire_lock(rule_lock); 4666 if (ice_find_rule_entry(rule_head, 4667 &m_list_itr->fltr_info)) { 4668 ice_release_lock(rule_lock); 4669 return ICE_ERR_ALREADY_EXISTS; 4670 } 4671 ice_release_lock(rule_lock); 4672 num_unicast++; 4673 } else if (IS_MULTICAST_ETHER_ADDR(add) || 4674 (IS_UNICAST_ETHER_ADDR(add) && hw->ucast_shared)) { 4675 m_list_itr->status = 4676 ice_add_rule_internal(hw, recp_list, lport, 4677 m_list_itr); 4678 if (m_list_itr->status) 4679 return m_list_itr->status; 4680 } 4681 } 4682 4683 ice_acquire_lock(rule_lock); 4684 /* Exit if no suitable entries were found for adding bulk switch rule */ 4685 if (!num_unicast) { 4686 status = ICE_SUCCESS; 4687 goto ice_add_mac_exit; 4688 } 4689 4690 /* Allocate switch rule buffer for the bulk update for unicast */ 4691 s_rule_size = ICE_SW_RULE_RX_TX_ETH_HDR_SIZE; 4692 s_rule = (struct ice_aqc_sw_rules_elem *) 4693 ice_calloc(hw, num_unicast, s_rule_size); 4694 if (!s_rule) { 4695 status = ICE_ERR_NO_MEMORY; 4696 goto ice_add_mac_exit; 4697 } 4698 4699 r_iter = s_rule; 4700 LIST_FOR_EACH_ENTRY(m_list_itr, m_list, ice_fltr_list_entry, 4701 list_entry) { 4702 struct ice_fltr_info *f_info = &m_list_itr->fltr_info; 4703 u8 *mac_addr = &f_info->l_data.mac.mac_addr[0]; 4704 4705 if (IS_UNICAST_ETHER_ADDR(mac_addr)) { 4706 ice_fill_sw_rule(hw, &m_list_itr->fltr_info, r_iter, 4707 ice_aqc_opc_add_sw_rules); 4708 r_iter = (struct ice_aqc_sw_rules_elem *) 4709 ((u8 *)r_iter + s_rule_size); 4710 } 4711 } 4712 4713 /* Call AQ bulk switch rule update for all unicast addresses */ 4714 r_iter = s_rule; 4715 /* Call AQ switch rule in AQ_MAX chunk */ 4716 for (total_elem_left = num_unicast; total_elem_left > 0; 4717 total_elem_left -= elem_sent) { 4718 struct ice_aqc_sw_rules_elem *entry = r_iter; 4719 4720 elem_sent = MIN_T(u8, total_elem_left, 4721 (ICE_AQ_MAX_BUF_LEN / s_rule_size)); 4722 status = ice_aq_sw_rules(hw, entry, elem_sent * s_rule_size, 4723 elem_sent, ice_aqc_opc_add_sw_rules, 4724 NULL); 4725 if (status) 4726 goto ice_add_mac_exit; 4727 r_iter = (struct ice_aqc_sw_rules_elem *) 4728 ((u8 *)r_iter + (elem_sent * s_rule_size)); 4729 } 4730 4731 /* Fill up rule ID based on the value returned from FW */ 4732 r_iter = s_rule; 4733 LIST_FOR_EACH_ENTRY(m_list_itr, m_list, ice_fltr_list_entry, 4734 list_entry) { 4735 struct ice_fltr_info *f_info = &m_list_itr->fltr_info; 4736 u8 *mac_addr = &f_info->l_data.mac.mac_addr[0]; 4737 struct ice_fltr_mgmt_list_entry *fm_entry; 4738 4739 if (IS_UNICAST_ETHER_ADDR(mac_addr)) { 4740 f_info->fltr_rule_id = 4741 LE16_TO_CPU(r_iter->pdata.lkup_tx_rx.index); 4742 f_info->fltr_act = ICE_FWD_TO_VSI; 4743 /* Create an entry to track this MAC address */ 4744 fm_entry = (struct ice_fltr_mgmt_list_entry *) 4745 ice_malloc(hw, sizeof(*fm_entry)); 4746 if (!fm_entry) { 4747 status = ICE_ERR_NO_MEMORY; 4748 goto ice_add_mac_exit; 4749 } 4750 fm_entry->fltr_info = *f_info; 4751 fm_entry->vsi_count = 1; 4752 /* The book keeping entries will get removed when 4753 * base driver calls remove filter AQ command 4754 */ 4755 4756 LIST_ADD(&fm_entry->list_entry, rule_head); 4757 r_iter = (struct ice_aqc_sw_rules_elem *) 4758 ((u8 *)r_iter + s_rule_size); 4759 } 4760 } 4761 4762 ice_add_mac_exit: 4763 ice_release_lock(rule_lock); 4764 if (s_rule) 4765 ice_free(hw, s_rule); 4766 return status; 4767 } 4768 4769 /** 4770 * ice_add_mac - Add a MAC address based filter rule 4771 * @hw: pointer to the hardware structure 4772 * @m_list: list of MAC addresses and forwarding information 4773 * 4774 * Function add MAC rule for logical port from HW struct 4775 */ 4776 enum ice_status ice_add_mac(struct ice_hw *hw, struct LIST_HEAD_TYPE *m_list) 4777 { 4778 if (!m_list || !hw) 4779 return ICE_ERR_PARAM; 4780 4781 return ice_add_mac_rule(hw, m_list, hw->switch_info, 4782 hw->port_info->lport); 4783 } 4784 4785 /** 4786 * ice_add_vlan_internal - Add one VLAN based filter rule 4787 * @hw: pointer to the hardware structure 4788 * @recp_list: recipe list for which rule has to be added 4789 * @f_entry: filter entry containing one VLAN information 4790 */ 4791 static enum ice_status 4792 ice_add_vlan_internal(struct ice_hw *hw, struct ice_sw_recipe *recp_list, 4793 struct ice_fltr_list_entry *f_entry) 4794 { 4795 struct ice_fltr_mgmt_list_entry *v_list_itr; 4796 struct ice_fltr_info *new_fltr, *cur_fltr; 4797 enum ice_sw_lkup_type lkup_type; 4798 u16 vsi_list_id = 0, vsi_handle; 4799 struct ice_lock *rule_lock; /* Lock to protect filter rule list */ 4800 enum ice_status status = ICE_SUCCESS; 4801 4802 if (!ice_is_vsi_valid(hw, f_entry->fltr_info.vsi_handle)) 4803 return ICE_ERR_PARAM; 4804 4805 f_entry->fltr_info.fwd_id.hw_vsi_id = 4806 ice_get_hw_vsi_num(hw, f_entry->fltr_info.vsi_handle); 4807 new_fltr = &f_entry->fltr_info; 4808 4809 /* VLAN ID should only be 12 bits */ 4810 if (new_fltr->l_data.vlan.vlan_id > ICE_MAX_VLAN_ID) 4811 return ICE_ERR_PARAM; 4812 4813 if (new_fltr->src_id != ICE_SRC_ID_VSI) 4814 return ICE_ERR_PARAM; 4815 4816 new_fltr->src = new_fltr->fwd_id.hw_vsi_id; 4817 lkup_type = new_fltr->lkup_type; 4818 vsi_handle = new_fltr->vsi_handle; 4819 rule_lock = &recp_list->filt_rule_lock; 4820 ice_acquire_lock(rule_lock); 4821 v_list_itr = ice_find_rule_entry(&recp_list->filt_rules, new_fltr); 4822 if (!v_list_itr) { 4823 struct ice_vsi_list_map_info *map_info = NULL; 4824 4825 if (new_fltr->fltr_act == ICE_FWD_TO_VSI) { 4826 /* All VLAN pruning rules use a VSI list. Check if 4827 * there is already a VSI list containing VSI that we 4828 * want to add. If found, use the same vsi_list_id for 4829 * this new VLAN rule or else create a new list. 4830 */ 4831 map_info = ice_find_vsi_list_entry(recp_list, 4832 vsi_handle, 4833 &vsi_list_id); 4834 if (!map_info) { 4835 status = ice_create_vsi_list_rule(hw, 4836 &vsi_handle, 4837 1, 4838 &vsi_list_id, 4839 lkup_type); 4840 if (status) 4841 goto exit; 4842 } 4843 /* Convert the action to forwarding to a VSI list. */ 4844 new_fltr->fltr_act = ICE_FWD_TO_VSI_LIST; 4845 new_fltr->fwd_id.vsi_list_id = vsi_list_id; 4846 } 4847 4848 status = ice_create_pkt_fwd_rule(hw, recp_list, f_entry); 4849 if (!status) { 4850 v_list_itr = ice_find_rule_entry(&recp_list->filt_rules, 4851 new_fltr); 4852 if (!v_list_itr) { 4853 status = ICE_ERR_DOES_NOT_EXIST; 4854 goto exit; 4855 } 4856 /* reuse VSI list for new rule and increment ref_cnt */ 4857 if (map_info) { 4858 v_list_itr->vsi_list_info = map_info; 4859 map_info->ref_cnt++; 4860 } else { 4861 v_list_itr->vsi_list_info = 4862 ice_create_vsi_list_map(hw, &vsi_handle, 4863 1, vsi_list_id); 4864 } 4865 } 4866 } else if (v_list_itr->vsi_list_info->ref_cnt == 1) { 4867 /* Update existing VSI list to add new VSI ID only if it used 4868 * by one VLAN rule. 4869 */ 4870 cur_fltr = &v_list_itr->fltr_info; 4871 status = ice_add_update_vsi_list(hw, v_list_itr, cur_fltr, 4872 new_fltr); 4873 } else { 4874 /* If VLAN rule exists and VSI list being used by this rule is 4875 * referenced by more than 1 VLAN rule. Then create a new VSI 4876 * list appending previous VSI with new VSI and update existing 4877 * VLAN rule to point to new VSI list ID 4878 */ 4879 struct ice_fltr_info tmp_fltr; 4880 u16 vsi_handle_arr[2]; 4881 u16 cur_handle; 4882 4883 /* Current implementation only supports reusing VSI list with 4884 * one VSI count. We should never hit below condition 4885 */ 4886 if (v_list_itr->vsi_count > 1 && 4887 v_list_itr->vsi_list_info->ref_cnt > 1) { 4888 ice_debug(hw, ICE_DBG_SW, "Invalid configuration: Optimization to reuse VSI list with more than one VSI is not being done yet\n"); 4889 status = ICE_ERR_CFG; 4890 goto exit; 4891 } 4892 4893 cur_handle = 4894 ice_find_first_bit(v_list_itr->vsi_list_info->vsi_map, 4895 ICE_MAX_VSI); 4896 4897 /* A rule already exists with the new VSI being added */ 4898 if (cur_handle == vsi_handle) { 4899 status = ICE_ERR_ALREADY_EXISTS; 4900 goto exit; 4901 } 4902 4903 vsi_handle_arr[0] = cur_handle; 4904 vsi_handle_arr[1] = vsi_handle; 4905 status = ice_create_vsi_list_rule(hw, &vsi_handle_arr[0], 2, 4906 &vsi_list_id, lkup_type); 4907 if (status) 4908 goto exit; 4909 4910 tmp_fltr = v_list_itr->fltr_info; 4911 tmp_fltr.fltr_rule_id = v_list_itr->fltr_info.fltr_rule_id; 4912 tmp_fltr.fwd_id.vsi_list_id = vsi_list_id; 4913 tmp_fltr.fltr_act = ICE_FWD_TO_VSI_LIST; 4914 /* Update the previous switch rule to a new VSI list which 4915 * includes current VSI that is requested 4916 */ 4917 status = ice_update_pkt_fwd_rule(hw, &tmp_fltr); 4918 if (status) 4919 goto exit; 4920 4921 /* before overriding VSI list map info. decrement ref_cnt of 4922 * previous VSI list 4923 */ 4924 v_list_itr->vsi_list_info->ref_cnt--; 4925 4926 /* now update to newly created list */ 4927 v_list_itr->fltr_info.fwd_id.vsi_list_id = vsi_list_id; 4928 v_list_itr->vsi_list_info = 4929 ice_create_vsi_list_map(hw, &vsi_handle_arr[0], 2, 4930 vsi_list_id); 4931 v_list_itr->vsi_count++; 4932 } 4933 4934 exit: 4935 ice_release_lock(rule_lock); 4936 return status; 4937 } 4938 4939 /** 4940 * ice_add_vlan_rule - Add VLAN based filter rule 4941 * @hw: pointer to the hardware structure 4942 * @v_list: list of VLAN entries and forwarding information 4943 * @sw: pointer to switch info struct for which function add rule 4944 */ 4945 static enum ice_status 4946 ice_add_vlan_rule(struct ice_hw *hw, struct LIST_HEAD_TYPE *v_list, 4947 struct ice_switch_info *sw) 4948 { 4949 struct ice_fltr_list_entry *v_list_itr; 4950 struct ice_sw_recipe *recp_list; 4951 4952 recp_list = &sw->recp_list[ICE_SW_LKUP_VLAN]; 4953 LIST_FOR_EACH_ENTRY(v_list_itr, v_list, ice_fltr_list_entry, 4954 list_entry) { 4955 if (v_list_itr->fltr_info.lkup_type != ICE_SW_LKUP_VLAN) 4956 return ICE_ERR_PARAM; 4957 v_list_itr->fltr_info.flag = ICE_FLTR_TX; 4958 v_list_itr->status = ice_add_vlan_internal(hw, recp_list, 4959 v_list_itr); 4960 if (v_list_itr->status) 4961 return v_list_itr->status; 4962 } 4963 return ICE_SUCCESS; 4964 } 4965 4966 /** 4967 * ice_add_vlan - Add a VLAN based filter rule 4968 * @hw: pointer to the hardware structure 4969 * @v_list: list of VLAN and forwarding information 4970 * 4971 * Function add VLAN rule for logical port from HW struct 4972 */ 4973 enum ice_status ice_add_vlan(struct ice_hw *hw, struct LIST_HEAD_TYPE *v_list) 4974 { 4975 if (!v_list || !hw) 4976 return ICE_ERR_PARAM; 4977 4978 return ice_add_vlan_rule(hw, v_list, hw->switch_info); 4979 } 4980 4981 /** 4982 * ice_add_mac_vlan - Add MAC and VLAN pair based filter rule 4983 * @hw: pointer to the hardware structure 4984 * @mv_list: list of MAC and VLAN filters 4985 * @sw: pointer to switch info struct for which function add rule 4986 * @lport: logic port number on which function add rule 4987 * 4988 * If the VSI on which the MAC-VLAN pair has to be added has Rx and Tx VLAN 4989 * pruning bits enabled, then it is the responsibility of the caller to make 4990 * sure to add a VLAN only filter on the same VSI. Packets belonging to that 4991 * VLAN won't be received on that VSI otherwise. 4992 */ 4993 static enum ice_status 4994 ice_add_mac_vlan_rule(struct ice_hw *hw, struct LIST_HEAD_TYPE *mv_list, 4995 struct ice_switch_info *sw, u8 lport) 4996 { 4997 struct ice_fltr_list_entry *mv_list_itr; 4998 struct ice_sw_recipe *recp_list; 4999 5000 if (!mv_list || !hw) 5001 return ICE_ERR_PARAM; 5002 5003 recp_list = &sw->recp_list[ICE_SW_LKUP_MAC_VLAN]; 5004 LIST_FOR_EACH_ENTRY(mv_list_itr, mv_list, ice_fltr_list_entry, 5005 list_entry) { 5006 enum ice_sw_lkup_type l_type = 5007 mv_list_itr->fltr_info.lkup_type; 5008 5009 if (l_type != ICE_SW_LKUP_MAC_VLAN) 5010 return ICE_ERR_PARAM; 5011 mv_list_itr->fltr_info.flag = ICE_FLTR_TX; 5012 mv_list_itr->status = 5013 ice_add_rule_internal(hw, recp_list, lport, 5014 mv_list_itr); 5015 if (mv_list_itr->status) 5016 return mv_list_itr->status; 5017 } 5018 return ICE_SUCCESS; 5019 } 5020 5021 /** 5022 * ice_add_mac_vlan - Add a MAC VLAN address based filter rule 5023 * @hw: pointer to the hardware structure 5024 * @mv_list: list of MAC VLAN addresses and forwarding information 5025 * 5026 * Function add MAC VLAN rule for logical port from HW struct 5027 */ 5028 enum ice_status 5029 ice_add_mac_vlan(struct ice_hw *hw, struct LIST_HEAD_TYPE *mv_list) 5030 { 5031 if (!mv_list || !hw) 5032 return ICE_ERR_PARAM; 5033 5034 return ice_add_mac_vlan_rule(hw, mv_list, hw->switch_info, 5035 hw->port_info->lport); 5036 } 5037 5038 /** 5039 * ice_add_eth_mac_rule - Add ethertype and MAC based filter rule 5040 * @hw: pointer to the hardware structure 5041 * @em_list: list of ether type MAC filter, MAC is optional 5042 * @sw: pointer to switch info struct for which function add rule 5043 * @lport: logic port number on which function add rule 5044 * 5045 * This function requires the caller to populate the entries in 5046 * the filter list with the necessary fields (including flags to 5047 * indicate Tx or Rx rules). 5048 */ 5049 static enum ice_status 5050 ice_add_eth_mac_rule(struct ice_hw *hw, struct LIST_HEAD_TYPE *em_list, 5051 struct ice_switch_info *sw, u8 lport) 5052 { 5053 struct ice_fltr_list_entry *em_list_itr; 5054 5055 LIST_FOR_EACH_ENTRY(em_list_itr, em_list, ice_fltr_list_entry, 5056 list_entry) { 5057 struct ice_sw_recipe *recp_list; 5058 enum ice_sw_lkup_type l_type; 5059 5060 l_type = em_list_itr->fltr_info.lkup_type; 5061 recp_list = &sw->recp_list[l_type]; 5062 5063 if (l_type != ICE_SW_LKUP_ETHERTYPE_MAC && 5064 l_type != ICE_SW_LKUP_ETHERTYPE) 5065 return ICE_ERR_PARAM; 5066 5067 em_list_itr->status = ice_add_rule_internal(hw, recp_list, 5068 lport, 5069 em_list_itr); 5070 if (em_list_itr->status) 5071 return em_list_itr->status; 5072 } 5073 return ICE_SUCCESS; 5074 } 5075 5076 /** 5077 * ice_add_eth_mac - Add a ethertype based filter rule 5078 * @hw: pointer to the hardware structure 5079 * @em_list: list of ethertype and forwarding information 5080 * 5081 * Function add ethertype rule for logical port from HW struct 5082 */ 5083 enum ice_status 5084 ice_add_eth_mac(struct ice_hw *hw, struct LIST_HEAD_TYPE *em_list) 5085 { 5086 if (!em_list || !hw) 5087 return ICE_ERR_PARAM; 5088 5089 return ice_add_eth_mac_rule(hw, em_list, hw->switch_info, 5090 hw->port_info->lport); 5091 } 5092 5093 /** 5094 * ice_remove_eth_mac_rule - Remove an ethertype (or MAC) based filter rule 5095 * @hw: pointer to the hardware structure 5096 * @em_list: list of ethertype or ethertype MAC entries 5097 * @sw: pointer to switch info struct for which function add rule 5098 */ 5099 static enum ice_status 5100 ice_remove_eth_mac_rule(struct ice_hw *hw, struct LIST_HEAD_TYPE *em_list, 5101 struct ice_switch_info *sw) 5102 { 5103 struct ice_fltr_list_entry *em_list_itr, *tmp; 5104 5105 LIST_FOR_EACH_ENTRY_SAFE(em_list_itr, tmp, em_list, ice_fltr_list_entry, 5106 list_entry) { 5107 struct ice_sw_recipe *recp_list; 5108 enum ice_sw_lkup_type l_type; 5109 5110 l_type = em_list_itr->fltr_info.lkup_type; 5111 5112 if (l_type != ICE_SW_LKUP_ETHERTYPE_MAC && 5113 l_type != ICE_SW_LKUP_ETHERTYPE) 5114 return ICE_ERR_PARAM; 5115 5116 recp_list = &sw->recp_list[l_type]; 5117 em_list_itr->status = ice_remove_rule_internal(hw, recp_list, 5118 em_list_itr); 5119 if (em_list_itr->status) 5120 return em_list_itr->status; 5121 } 5122 return ICE_SUCCESS; 5123 } 5124 5125 /** 5126 * ice_remove_eth_mac - remove a ethertype based filter rule 5127 * @hw: pointer to the hardware structure 5128 * @em_list: list of ethertype and forwarding information 5129 * 5130 */ 5131 enum ice_status 5132 ice_remove_eth_mac(struct ice_hw *hw, struct LIST_HEAD_TYPE *em_list) 5133 { 5134 if (!em_list || !hw) 5135 return ICE_ERR_PARAM; 5136 5137 return ice_remove_eth_mac_rule(hw, em_list, hw->switch_info); 5138 } 5139 5140 /** 5141 * ice_rem_sw_rule_info 5142 * @hw: pointer to the hardware structure 5143 * @rule_head: pointer to the switch list structure that we want to delete 5144 */ 5145 static void 5146 ice_rem_sw_rule_info(struct ice_hw *hw, struct LIST_HEAD_TYPE *rule_head) 5147 { 5148 if (!LIST_EMPTY(rule_head)) { 5149 struct ice_fltr_mgmt_list_entry *entry; 5150 struct ice_fltr_mgmt_list_entry *tmp; 5151 5152 LIST_FOR_EACH_ENTRY_SAFE(entry, tmp, rule_head, 5153 ice_fltr_mgmt_list_entry, list_entry) { 5154 LIST_DEL(&entry->list_entry); 5155 ice_free(hw, entry); 5156 } 5157 } 5158 } 5159 5160 /** 5161 * ice_rem_adv_rule_info 5162 * @hw: pointer to the hardware structure 5163 * @rule_head: pointer to the switch list structure that we want to delete 5164 */ 5165 static void 5166 ice_rem_adv_rule_info(struct ice_hw *hw, struct LIST_HEAD_TYPE *rule_head) 5167 { 5168 struct ice_adv_fltr_mgmt_list_entry *tmp_entry; 5169 struct ice_adv_fltr_mgmt_list_entry *lst_itr; 5170 5171 if (LIST_EMPTY(rule_head)) 5172 return; 5173 5174 LIST_FOR_EACH_ENTRY_SAFE(lst_itr, tmp_entry, rule_head, 5175 ice_adv_fltr_mgmt_list_entry, list_entry) { 5176 LIST_DEL(&lst_itr->list_entry); 5177 ice_free(hw, lst_itr->lkups); 5178 ice_free(hw, lst_itr); 5179 } 5180 } 5181 5182 /** 5183 * ice_rem_all_sw_rules_info 5184 * @hw: pointer to the hardware structure 5185 */ 5186 void ice_rem_all_sw_rules_info(struct ice_hw *hw) 5187 { 5188 struct ice_switch_info *sw = hw->switch_info; 5189 u8 i; 5190 5191 for (i = 0; i < ICE_MAX_NUM_RECIPES; i++) { 5192 struct LIST_HEAD_TYPE *rule_head; 5193 5194 rule_head = &sw->recp_list[i].filt_rules; 5195 if (!sw->recp_list[i].adv_rule) 5196 ice_rem_sw_rule_info(hw, rule_head); 5197 else 5198 ice_rem_adv_rule_info(hw, rule_head); 5199 if (sw->recp_list[i].adv_rule && 5200 LIST_EMPTY(&sw->recp_list[i].filt_rules)) 5201 sw->recp_list[i].adv_rule = false; 5202 } 5203 } 5204 5205 /** 5206 * ice_cfg_dflt_vsi - change state of VSI to set/clear default 5207 * @pi: pointer to the port_info structure 5208 * @vsi_handle: VSI handle to set as default 5209 * @set: true to add the above mentioned switch rule, false to remove it 5210 * @direction: ICE_FLTR_RX or ICE_FLTR_TX 5211 * 5212 * add filter rule to set/unset given VSI as default VSI for the switch 5213 * (represented by swid) 5214 */ 5215 enum ice_status 5216 ice_cfg_dflt_vsi(struct ice_port_info *pi, u16 vsi_handle, bool set, 5217 u8 direction) 5218 { 5219 struct ice_aqc_sw_rules_elem *s_rule; 5220 struct ice_fltr_info f_info; 5221 struct ice_hw *hw = pi->hw; 5222 enum ice_adminq_opc opcode; 5223 enum ice_status status; 5224 u16 s_rule_size; 5225 u16 hw_vsi_id; 5226 5227 if (!ice_is_vsi_valid(hw, vsi_handle)) 5228 return ICE_ERR_PARAM; 5229 hw_vsi_id = ice_get_hw_vsi_num(hw, vsi_handle); 5230 5231 s_rule_size = set ? ICE_SW_RULE_RX_TX_ETH_HDR_SIZE : 5232 ICE_SW_RULE_RX_TX_NO_HDR_SIZE; 5233 5234 s_rule = (struct ice_aqc_sw_rules_elem *)ice_malloc(hw, s_rule_size); 5235 if (!s_rule) 5236 return ICE_ERR_NO_MEMORY; 5237 5238 ice_memset(&f_info, 0, sizeof(f_info), ICE_NONDMA_MEM); 5239 5240 f_info.lkup_type = ICE_SW_LKUP_DFLT; 5241 f_info.flag = direction; 5242 f_info.fltr_act = ICE_FWD_TO_VSI; 5243 f_info.fwd_id.hw_vsi_id = hw_vsi_id; 5244 5245 if (f_info.flag & ICE_FLTR_RX) { 5246 f_info.src = pi->lport; 5247 f_info.src_id = ICE_SRC_ID_LPORT; 5248 if (!set) 5249 f_info.fltr_rule_id = 5250 pi->dflt_rx_vsi_rule_id; 5251 } else if (f_info.flag & ICE_FLTR_TX) { 5252 f_info.src_id = ICE_SRC_ID_VSI; 5253 f_info.src = hw_vsi_id; 5254 if (!set) 5255 f_info.fltr_rule_id = 5256 pi->dflt_tx_vsi_rule_id; 5257 } 5258 5259 if (set) 5260 opcode = ice_aqc_opc_add_sw_rules; 5261 else 5262 opcode = ice_aqc_opc_remove_sw_rules; 5263 5264 ice_fill_sw_rule(hw, &f_info, s_rule, opcode); 5265 5266 status = ice_aq_sw_rules(hw, s_rule, s_rule_size, 1, opcode, NULL); 5267 if (status || !(f_info.flag & ICE_FLTR_TX_RX)) 5268 goto out; 5269 if (set) { 5270 u16 index = LE16_TO_CPU(s_rule->pdata.lkup_tx_rx.index); 5271 5272 if (f_info.flag & ICE_FLTR_TX) { 5273 pi->dflt_tx_vsi_num = hw_vsi_id; 5274 pi->dflt_tx_vsi_rule_id = index; 5275 } else if (f_info.flag & ICE_FLTR_RX) { 5276 pi->dflt_rx_vsi_num = hw_vsi_id; 5277 pi->dflt_rx_vsi_rule_id = index; 5278 } 5279 } else { 5280 if (f_info.flag & ICE_FLTR_TX) { 5281 pi->dflt_tx_vsi_num = ICE_DFLT_VSI_INVAL; 5282 pi->dflt_tx_vsi_rule_id = ICE_INVAL_ACT; 5283 } else if (f_info.flag & ICE_FLTR_RX) { 5284 pi->dflt_rx_vsi_num = ICE_DFLT_VSI_INVAL; 5285 pi->dflt_rx_vsi_rule_id = ICE_INVAL_ACT; 5286 } 5287 } 5288 5289 out: 5290 ice_free(hw, s_rule); 5291 return status; 5292 } 5293 5294 /** 5295 * ice_find_ucast_rule_entry - Search for a unicast MAC filter rule entry 5296 * @list_head: head of rule list 5297 * @f_info: rule information 5298 * 5299 * Helper function to search for a unicast rule entry - this is to be used 5300 * to remove unicast MAC filter that is not shared with other VSIs on the 5301 * PF switch. 5302 * 5303 * Returns pointer to entry storing the rule if found 5304 */ 5305 static struct ice_fltr_mgmt_list_entry * 5306 ice_find_ucast_rule_entry(struct LIST_HEAD_TYPE *list_head, 5307 struct ice_fltr_info *f_info) 5308 { 5309 struct ice_fltr_mgmt_list_entry *list_itr; 5310 5311 LIST_FOR_EACH_ENTRY(list_itr, list_head, ice_fltr_mgmt_list_entry, 5312 list_entry) { 5313 if (!memcmp(&f_info->l_data, &list_itr->fltr_info.l_data, 5314 sizeof(f_info->l_data)) && 5315 f_info->fwd_id.hw_vsi_id == 5316 list_itr->fltr_info.fwd_id.hw_vsi_id && 5317 f_info->flag == list_itr->fltr_info.flag) 5318 return list_itr; 5319 } 5320 return NULL; 5321 } 5322 5323 /** 5324 * ice_remove_mac_rule - remove a MAC based filter rule 5325 * @hw: pointer to the hardware structure 5326 * @m_list: list of MAC addresses and forwarding information 5327 * @recp_list: list from which function remove MAC address 5328 * 5329 * This function removes either a MAC filter rule or a specific VSI from a 5330 * VSI list for a multicast MAC address. 5331 * 5332 * Returns ICE_ERR_DOES_NOT_EXIST if a given entry was not added by 5333 * ice_add_mac. Caller should be aware that this call will only work if all 5334 * the entries passed into m_list were added previously. It will not attempt to 5335 * do a partial remove of entries that were found. 5336 */ 5337 static enum ice_status 5338 ice_remove_mac_rule(struct ice_hw *hw, struct LIST_HEAD_TYPE *m_list, 5339 struct ice_sw_recipe *recp_list) 5340 { 5341 struct ice_fltr_list_entry *list_itr, *tmp; 5342 struct ice_lock *rule_lock; /* Lock to protect filter rule list */ 5343 5344 if (!m_list) 5345 return ICE_ERR_PARAM; 5346 5347 rule_lock = &recp_list->filt_rule_lock; 5348 LIST_FOR_EACH_ENTRY_SAFE(list_itr, tmp, m_list, ice_fltr_list_entry, 5349 list_entry) { 5350 enum ice_sw_lkup_type l_type = list_itr->fltr_info.lkup_type; 5351 u8 *add = &list_itr->fltr_info.l_data.mac.mac_addr[0]; 5352 u16 vsi_handle; 5353 5354 if (l_type != ICE_SW_LKUP_MAC) 5355 return ICE_ERR_PARAM; 5356 5357 vsi_handle = list_itr->fltr_info.vsi_handle; 5358 if (!ice_is_vsi_valid(hw, vsi_handle)) 5359 return ICE_ERR_PARAM; 5360 5361 list_itr->fltr_info.fwd_id.hw_vsi_id = 5362 ice_get_hw_vsi_num(hw, vsi_handle); 5363 if (IS_UNICAST_ETHER_ADDR(add) && !hw->ucast_shared) { 5364 /* Don't remove the unicast address that belongs to 5365 * another VSI on the switch, since it is not being 5366 * shared... 5367 */ 5368 ice_acquire_lock(rule_lock); 5369 if (!ice_find_ucast_rule_entry(&recp_list->filt_rules, 5370 &list_itr->fltr_info)) { 5371 ice_release_lock(rule_lock); 5372 return ICE_ERR_DOES_NOT_EXIST; 5373 } 5374 ice_release_lock(rule_lock); 5375 } 5376 list_itr->status = ice_remove_rule_internal(hw, recp_list, 5377 list_itr); 5378 if (list_itr->status) 5379 return list_itr->status; 5380 } 5381 return ICE_SUCCESS; 5382 } 5383 5384 /** 5385 * ice_remove_mac - remove a MAC address based filter rule 5386 * @hw: pointer to the hardware structure 5387 * @m_list: list of MAC addresses and forwarding information 5388 * 5389 */ 5390 enum ice_status ice_remove_mac(struct ice_hw *hw, struct LIST_HEAD_TYPE *m_list) 5391 { 5392 struct ice_sw_recipe *recp_list; 5393 5394 recp_list = &hw->switch_info->recp_list[ICE_SW_LKUP_MAC]; 5395 return ice_remove_mac_rule(hw, m_list, recp_list); 5396 } 5397 5398 /** 5399 * ice_remove_vlan_rule - Remove VLAN based filter rule 5400 * @hw: pointer to the hardware structure 5401 * @v_list: list of VLAN entries and forwarding information 5402 * @recp_list: list from which function remove VLAN 5403 */ 5404 static enum ice_status 5405 ice_remove_vlan_rule(struct ice_hw *hw, struct LIST_HEAD_TYPE *v_list, 5406 struct ice_sw_recipe *recp_list) 5407 { 5408 struct ice_fltr_list_entry *v_list_itr, *tmp; 5409 5410 LIST_FOR_EACH_ENTRY_SAFE(v_list_itr, tmp, v_list, ice_fltr_list_entry, 5411 list_entry) { 5412 enum ice_sw_lkup_type l_type = v_list_itr->fltr_info.lkup_type; 5413 5414 if (l_type != ICE_SW_LKUP_VLAN) 5415 return ICE_ERR_PARAM; 5416 v_list_itr->status = ice_remove_rule_internal(hw, recp_list, 5417 v_list_itr); 5418 if (v_list_itr->status) 5419 return v_list_itr->status; 5420 } 5421 return ICE_SUCCESS; 5422 } 5423 5424 /** 5425 * ice_remove_vlan - remove a VLAN address based filter rule 5426 * @hw: pointer to the hardware structure 5427 * @v_list: list of VLAN and forwarding information 5428 * 5429 */ 5430 enum ice_status 5431 ice_remove_vlan(struct ice_hw *hw, struct LIST_HEAD_TYPE *v_list) 5432 { 5433 struct ice_sw_recipe *recp_list; 5434 5435 if (!v_list || !hw) 5436 return ICE_ERR_PARAM; 5437 5438 recp_list = &hw->switch_info->recp_list[ICE_SW_LKUP_VLAN]; 5439 return ice_remove_vlan_rule(hw, v_list, recp_list); 5440 } 5441 5442 /** 5443 * ice_remove_mac_vlan_rule - Remove MAC VLAN based filter rule 5444 * @hw: pointer to the hardware structure 5445 * @v_list: list of MAC VLAN entries and forwarding information 5446 * @recp_list: list from which function remove MAC VLAN 5447 */ 5448 static enum ice_status 5449 ice_remove_mac_vlan_rule(struct ice_hw *hw, struct LIST_HEAD_TYPE *v_list, 5450 struct ice_sw_recipe *recp_list) 5451 { 5452 struct ice_fltr_list_entry *v_list_itr, *tmp; 5453 5454 recp_list = &hw->switch_info->recp_list[ICE_SW_LKUP_MAC_VLAN]; 5455 LIST_FOR_EACH_ENTRY_SAFE(v_list_itr, tmp, v_list, ice_fltr_list_entry, 5456 list_entry) { 5457 enum ice_sw_lkup_type l_type = v_list_itr->fltr_info.lkup_type; 5458 5459 if (l_type != ICE_SW_LKUP_MAC_VLAN) 5460 return ICE_ERR_PARAM; 5461 v_list_itr->status = 5462 ice_remove_rule_internal(hw, recp_list, 5463 v_list_itr); 5464 if (v_list_itr->status) 5465 return v_list_itr->status; 5466 } 5467 return ICE_SUCCESS; 5468 } 5469 5470 /** 5471 * ice_remove_mac_vlan - remove a MAC VLAN address based filter rule 5472 * @hw: pointer to the hardware structure 5473 * @mv_list: list of MAC VLAN and forwarding information 5474 */ 5475 enum ice_status 5476 ice_remove_mac_vlan(struct ice_hw *hw, struct LIST_HEAD_TYPE *mv_list) 5477 { 5478 struct ice_sw_recipe *recp_list; 5479 5480 if (!mv_list || !hw) 5481 return ICE_ERR_PARAM; 5482 5483 recp_list = &hw->switch_info->recp_list[ICE_SW_LKUP_MAC_VLAN]; 5484 return ice_remove_mac_vlan_rule(hw, mv_list, recp_list); 5485 } 5486 5487 /** 5488 * ice_vsi_uses_fltr - Determine if given VSI uses specified filter 5489 * @fm_entry: filter entry to inspect 5490 * @vsi_handle: VSI handle to compare with filter info 5491 */ 5492 static bool 5493 ice_vsi_uses_fltr(struct ice_fltr_mgmt_list_entry *fm_entry, u16 vsi_handle) 5494 { 5495 return ((fm_entry->fltr_info.fltr_act == ICE_FWD_TO_VSI && 5496 fm_entry->fltr_info.vsi_handle == vsi_handle) || 5497 (fm_entry->fltr_info.fltr_act == ICE_FWD_TO_VSI_LIST && 5498 fm_entry->vsi_list_info && 5499 (ice_is_bit_set(fm_entry->vsi_list_info->vsi_map, 5500 vsi_handle)))); 5501 } 5502 5503 /** 5504 * ice_add_entry_to_vsi_fltr_list - Add copy of fltr_list_entry to remove list 5505 * @hw: pointer to the hardware structure 5506 * @vsi_handle: VSI handle to remove filters from 5507 * @vsi_list_head: pointer to the list to add entry to 5508 * @fi: pointer to fltr_info of filter entry to copy & add 5509 * 5510 * Helper function, used when creating a list of filters to remove from 5511 * a specific VSI. The entry added to vsi_list_head is a COPY of the 5512 * original filter entry, with the exception of fltr_info.fltr_act and 5513 * fltr_info.fwd_id fields. These are set such that later logic can 5514 * extract which VSI to remove the fltr from, and pass on that information. 5515 */ 5516 static enum ice_status 5517 ice_add_entry_to_vsi_fltr_list(struct ice_hw *hw, u16 vsi_handle, 5518 struct LIST_HEAD_TYPE *vsi_list_head, 5519 struct ice_fltr_info *fi) 5520 { 5521 struct ice_fltr_list_entry *tmp; 5522 5523 /* this memory is freed up in the caller function 5524 * once filters for this VSI are removed 5525 */ 5526 tmp = (struct ice_fltr_list_entry *)ice_malloc(hw, sizeof(*tmp)); 5527 if (!tmp) 5528 return ICE_ERR_NO_MEMORY; 5529 5530 tmp->fltr_info = *fi; 5531 5532 /* Overwrite these fields to indicate which VSI to remove filter from, 5533 * so find and remove logic can extract the information from the 5534 * list entries. Note that original entries will still have proper 5535 * values. 5536 */ 5537 tmp->fltr_info.fltr_act = ICE_FWD_TO_VSI; 5538 tmp->fltr_info.vsi_handle = vsi_handle; 5539 tmp->fltr_info.fwd_id.hw_vsi_id = ice_get_hw_vsi_num(hw, vsi_handle); 5540 5541 LIST_ADD(&tmp->list_entry, vsi_list_head); 5542 5543 return ICE_SUCCESS; 5544 } 5545 5546 /** 5547 * ice_add_to_vsi_fltr_list - Add VSI filters to the list 5548 * @hw: pointer to the hardware structure 5549 * @vsi_handle: VSI handle to remove filters from 5550 * @lkup_list_head: pointer to the list that has certain lookup type filters 5551 * @vsi_list_head: pointer to the list pertaining to VSI with vsi_handle 5552 * 5553 * Locates all filters in lkup_list_head that are used by the given VSI, 5554 * and adds COPIES of those entries to vsi_list_head (intended to be used 5555 * to remove the listed filters). 5556 * Note that this means all entries in vsi_list_head must be explicitly 5557 * deallocated by the caller when done with list. 5558 */ 5559 static enum ice_status 5560 ice_add_to_vsi_fltr_list(struct ice_hw *hw, u16 vsi_handle, 5561 struct LIST_HEAD_TYPE *lkup_list_head, 5562 struct LIST_HEAD_TYPE *vsi_list_head) 5563 { 5564 struct ice_fltr_mgmt_list_entry *fm_entry; 5565 enum ice_status status = ICE_SUCCESS; 5566 5567 /* check to make sure VSI ID is valid and within boundary */ 5568 if (!ice_is_vsi_valid(hw, vsi_handle)) 5569 return ICE_ERR_PARAM; 5570 5571 LIST_FOR_EACH_ENTRY(fm_entry, lkup_list_head, 5572 ice_fltr_mgmt_list_entry, list_entry) { 5573 if (!ice_vsi_uses_fltr(fm_entry, vsi_handle)) 5574 continue; 5575 5576 status = ice_add_entry_to_vsi_fltr_list(hw, vsi_handle, 5577 vsi_list_head, 5578 &fm_entry->fltr_info); 5579 if (status) 5580 return status; 5581 } 5582 return status; 5583 } 5584 5585 /** 5586 * ice_determine_promisc_mask 5587 * @fi: filter info to parse 5588 * 5589 * Helper function to determine which ICE_PROMISC_ mask corresponds 5590 * to given filter into. 5591 */ 5592 static u8 ice_determine_promisc_mask(struct ice_fltr_info *fi) 5593 { 5594 u16 vid = fi->l_data.mac_vlan.vlan_id; 5595 u8 *macaddr = fi->l_data.mac.mac_addr; 5596 bool is_tx_fltr = false; 5597 u8 promisc_mask = 0; 5598 5599 if (fi->flag == ICE_FLTR_TX) 5600 is_tx_fltr = true; 5601 5602 if (IS_BROADCAST_ETHER_ADDR(macaddr)) 5603 promisc_mask |= is_tx_fltr ? 5604 ICE_PROMISC_BCAST_TX : ICE_PROMISC_BCAST_RX; 5605 else if (IS_MULTICAST_ETHER_ADDR(macaddr)) 5606 promisc_mask |= is_tx_fltr ? 5607 ICE_PROMISC_MCAST_TX : ICE_PROMISC_MCAST_RX; 5608 else if (IS_UNICAST_ETHER_ADDR(macaddr)) 5609 promisc_mask |= is_tx_fltr ? 5610 ICE_PROMISC_UCAST_TX : ICE_PROMISC_UCAST_RX; 5611 if (vid) 5612 promisc_mask |= is_tx_fltr ? 5613 ICE_PROMISC_VLAN_TX : ICE_PROMISC_VLAN_RX; 5614 5615 return promisc_mask; 5616 } 5617 5618 /** 5619 * _ice_get_vsi_promisc - get promiscuous mode of given VSI 5620 * @hw: pointer to the hardware structure 5621 * @vsi_handle: VSI handle to retrieve info from 5622 * @promisc_mask: pointer to mask to be filled in 5623 * @vid: VLAN ID of promisc VLAN VSI 5624 * @sw: pointer to switch info struct for which function add rule 5625 */ 5626 static enum ice_status 5627 _ice_get_vsi_promisc(struct ice_hw *hw, u16 vsi_handle, u8 *promisc_mask, 5628 u16 *vid, struct ice_switch_info *sw) 5629 { 5630 struct ice_fltr_mgmt_list_entry *itr; 5631 struct LIST_HEAD_TYPE *rule_head; 5632 struct ice_lock *rule_lock; /* Lock to protect filter rule list */ 5633 5634 if (!ice_is_vsi_valid(hw, vsi_handle)) 5635 return ICE_ERR_PARAM; 5636 5637 *vid = 0; 5638 *promisc_mask = 0; 5639 rule_head = &sw->recp_list[ICE_SW_LKUP_PROMISC].filt_rules; 5640 rule_lock = &sw->recp_list[ICE_SW_LKUP_PROMISC].filt_rule_lock; 5641 5642 ice_acquire_lock(rule_lock); 5643 LIST_FOR_EACH_ENTRY(itr, rule_head, 5644 ice_fltr_mgmt_list_entry, list_entry) { 5645 /* Continue if this filter doesn't apply to this VSI or the 5646 * VSI ID is not in the VSI map for this filter 5647 */ 5648 if (!ice_vsi_uses_fltr(itr, vsi_handle)) 5649 continue; 5650 5651 *promisc_mask |= ice_determine_promisc_mask(&itr->fltr_info); 5652 } 5653 ice_release_lock(rule_lock); 5654 5655 return ICE_SUCCESS; 5656 } 5657 5658 /** 5659 * ice_get_vsi_promisc - get promiscuous mode of given VSI 5660 * @hw: pointer to the hardware structure 5661 * @vsi_handle: VSI handle to retrieve info from 5662 * @promisc_mask: pointer to mask to be filled in 5663 * @vid: VLAN ID of promisc VLAN VSI 5664 */ 5665 enum ice_status 5666 ice_get_vsi_promisc(struct ice_hw *hw, u16 vsi_handle, u8 *promisc_mask, 5667 u16 *vid) 5668 { 5669 return _ice_get_vsi_promisc(hw, vsi_handle, promisc_mask, 5670 vid, hw->switch_info); 5671 } 5672 5673 /** 5674 * ice_get_vsi_vlan_promisc - get VLAN promiscuous mode of given VSI 5675 * @hw: pointer to the hardware structure 5676 * @vsi_handle: VSI handle to retrieve info from 5677 * @promisc_mask: pointer to mask to be filled in 5678 * @vid: VLAN ID of promisc VLAN VSI 5679 * @sw: pointer to switch info struct for which function add rule 5680 */ 5681 static enum ice_status 5682 _ice_get_vsi_vlan_promisc(struct ice_hw *hw, u16 vsi_handle, u8 *promisc_mask, 5683 u16 *vid, struct ice_switch_info *sw) 5684 { 5685 struct ice_fltr_mgmt_list_entry *itr; 5686 struct LIST_HEAD_TYPE *rule_head; 5687 struct ice_lock *rule_lock; /* Lock to protect filter rule list */ 5688 5689 if (!ice_is_vsi_valid(hw, vsi_handle)) 5690 return ICE_ERR_PARAM; 5691 5692 *vid = 0; 5693 *promisc_mask = 0; 5694 rule_head = &sw->recp_list[ICE_SW_LKUP_PROMISC_VLAN].filt_rules; 5695 rule_lock = &sw->recp_list[ICE_SW_LKUP_PROMISC_VLAN].filt_rule_lock; 5696 5697 ice_acquire_lock(rule_lock); 5698 LIST_FOR_EACH_ENTRY(itr, rule_head, ice_fltr_mgmt_list_entry, 5699 list_entry) { 5700 /* Continue if this filter doesn't apply to this VSI or the 5701 * VSI ID is not in the VSI map for this filter 5702 */ 5703 if (!ice_vsi_uses_fltr(itr, vsi_handle)) 5704 continue; 5705 5706 *promisc_mask |= ice_determine_promisc_mask(&itr->fltr_info); 5707 } 5708 ice_release_lock(rule_lock); 5709 5710 return ICE_SUCCESS; 5711 } 5712 5713 /** 5714 * ice_get_vsi_vlan_promisc - get VLAN promiscuous mode of given VSI 5715 * @hw: pointer to the hardware structure 5716 * @vsi_handle: VSI handle to retrieve info from 5717 * @promisc_mask: pointer to mask to be filled in 5718 * @vid: VLAN ID of promisc VLAN VSI 5719 */ 5720 enum ice_status 5721 ice_get_vsi_vlan_promisc(struct ice_hw *hw, u16 vsi_handle, u8 *promisc_mask, 5722 u16 *vid) 5723 { 5724 return _ice_get_vsi_vlan_promisc(hw, vsi_handle, promisc_mask, 5725 vid, hw->switch_info); 5726 } 5727 5728 /** 5729 * ice_remove_promisc - Remove promisc based filter rules 5730 * @hw: pointer to the hardware structure 5731 * @recp_id: recipe ID for which the rule needs to removed 5732 * @v_list: list of promisc entries 5733 */ 5734 static enum ice_status 5735 ice_remove_promisc(struct ice_hw *hw, u8 recp_id, 5736 struct LIST_HEAD_TYPE *v_list) 5737 { 5738 struct ice_fltr_list_entry *v_list_itr, *tmp; 5739 struct ice_sw_recipe *recp_list; 5740 5741 recp_list = &hw->switch_info->recp_list[recp_id]; 5742 LIST_FOR_EACH_ENTRY_SAFE(v_list_itr, tmp, v_list, ice_fltr_list_entry, 5743 list_entry) { 5744 v_list_itr->status = 5745 ice_remove_rule_internal(hw, recp_list, v_list_itr); 5746 if (v_list_itr->status) 5747 return v_list_itr->status; 5748 } 5749 return ICE_SUCCESS; 5750 } 5751 5752 /** 5753 * _ice_clear_vsi_promisc - clear specified promiscuous mode(s) 5754 * @hw: pointer to the hardware structure 5755 * @vsi_handle: VSI handle to clear mode 5756 * @promisc_mask: mask of promiscuous config bits to clear 5757 * @vid: VLAN ID to clear VLAN promiscuous 5758 * @sw: pointer to switch info struct for which function add rule 5759 */ 5760 static enum ice_status 5761 _ice_clear_vsi_promisc(struct ice_hw *hw, u16 vsi_handle, u8 promisc_mask, 5762 u16 vid, struct ice_switch_info *sw) 5763 { 5764 struct ice_fltr_list_entry *fm_entry, *tmp; 5765 struct LIST_HEAD_TYPE remove_list_head; 5766 struct ice_fltr_mgmt_list_entry *itr; 5767 struct LIST_HEAD_TYPE *rule_head; 5768 struct ice_lock *rule_lock; /* Lock to protect filter rule list */ 5769 enum ice_status status = ICE_SUCCESS; 5770 u8 recipe_id; 5771 5772 if (!ice_is_vsi_valid(hw, vsi_handle)) 5773 return ICE_ERR_PARAM; 5774 5775 if (promisc_mask & (ICE_PROMISC_VLAN_RX | ICE_PROMISC_VLAN_TX)) 5776 recipe_id = ICE_SW_LKUP_PROMISC_VLAN; 5777 else 5778 recipe_id = ICE_SW_LKUP_PROMISC; 5779 5780 rule_head = &sw->recp_list[recipe_id].filt_rules; 5781 rule_lock = &sw->recp_list[recipe_id].filt_rule_lock; 5782 5783 INIT_LIST_HEAD(&remove_list_head); 5784 5785 ice_acquire_lock(rule_lock); 5786 LIST_FOR_EACH_ENTRY(itr, rule_head, 5787 ice_fltr_mgmt_list_entry, list_entry) { 5788 struct ice_fltr_info *fltr_info; 5789 u8 fltr_promisc_mask = 0; 5790 5791 if (!ice_vsi_uses_fltr(itr, vsi_handle)) 5792 continue; 5793 fltr_info = &itr->fltr_info; 5794 5795 if (recipe_id == ICE_SW_LKUP_PROMISC_VLAN && 5796 vid != fltr_info->l_data.mac_vlan.vlan_id) 5797 continue; 5798 5799 fltr_promisc_mask |= ice_determine_promisc_mask(fltr_info); 5800 5801 /* Skip if filter is not completely specified by given mask */ 5802 if (fltr_promisc_mask & ~promisc_mask) 5803 continue; 5804 5805 status = ice_add_entry_to_vsi_fltr_list(hw, vsi_handle, 5806 &remove_list_head, 5807 fltr_info); 5808 if (status) { 5809 ice_release_lock(rule_lock); 5810 goto free_fltr_list; 5811 } 5812 } 5813 ice_release_lock(rule_lock); 5814 5815 status = ice_remove_promisc(hw, recipe_id, &remove_list_head); 5816 5817 free_fltr_list: 5818 LIST_FOR_EACH_ENTRY_SAFE(fm_entry, tmp, &remove_list_head, 5819 ice_fltr_list_entry, list_entry) { 5820 LIST_DEL(&fm_entry->list_entry); 5821 ice_free(hw, fm_entry); 5822 } 5823 5824 return status; 5825 } 5826 5827 /** 5828 * ice_clear_vsi_promisc - clear specified promiscuous mode(s) for given VSI 5829 * @hw: pointer to the hardware structure 5830 * @vsi_handle: VSI handle to clear mode 5831 * @promisc_mask: mask of promiscuous config bits to clear 5832 * @vid: VLAN ID to clear VLAN promiscuous 5833 */ 5834 enum ice_status 5835 ice_clear_vsi_promisc(struct ice_hw *hw, u16 vsi_handle, 5836 u8 promisc_mask, u16 vid) 5837 { 5838 return _ice_clear_vsi_promisc(hw, vsi_handle, promisc_mask, 5839 vid, hw->switch_info); 5840 } 5841 5842 /** 5843 * _ice_set_vsi_promisc - set given VSI to given promiscuous mode(s) 5844 * @hw: pointer to the hardware structure 5845 * @vsi_handle: VSI handle to configure 5846 * @promisc_mask: mask of promiscuous config bits 5847 * @vid: VLAN ID to set VLAN promiscuous 5848 * @lport: logical port number to configure promisc mode 5849 * @sw: pointer to switch info struct for which function add rule 5850 */ 5851 static enum ice_status 5852 _ice_set_vsi_promisc(struct ice_hw *hw, u16 vsi_handle, u8 promisc_mask, 5853 u16 vid, u8 lport, struct ice_switch_info *sw) 5854 { 5855 enum { UCAST_FLTR = 1, MCAST_FLTR, BCAST_FLTR }; 5856 struct ice_fltr_list_entry f_list_entry; 5857 struct ice_fltr_info new_fltr; 5858 enum ice_status status = ICE_SUCCESS; 5859 bool is_tx_fltr; 5860 u16 hw_vsi_id; 5861 int pkt_type; 5862 u8 recipe_id; 5863 5864 ice_debug(hw, ICE_DBG_TRACE, "%s\n", __func__); 5865 5866 if (!ice_is_vsi_valid(hw, vsi_handle)) 5867 return ICE_ERR_PARAM; 5868 hw_vsi_id = ice_get_hw_vsi_num(hw, vsi_handle); 5869 5870 ice_memset(&new_fltr, 0, sizeof(new_fltr), ICE_NONDMA_MEM); 5871 5872 if (promisc_mask & (ICE_PROMISC_VLAN_RX | ICE_PROMISC_VLAN_TX)) { 5873 new_fltr.lkup_type = ICE_SW_LKUP_PROMISC_VLAN; 5874 new_fltr.l_data.mac_vlan.vlan_id = vid; 5875 recipe_id = ICE_SW_LKUP_PROMISC_VLAN; 5876 } else { 5877 new_fltr.lkup_type = ICE_SW_LKUP_PROMISC; 5878 recipe_id = ICE_SW_LKUP_PROMISC; 5879 } 5880 5881 /* Separate filters must be set for each direction/packet type 5882 * combination, so we will loop over the mask value, store the 5883 * individual type, and clear it out in the input mask as it 5884 * is found. 5885 */ 5886 while (promisc_mask) { 5887 struct ice_sw_recipe *recp_list; 5888 u8 *mac_addr; 5889 5890 pkt_type = 0; 5891 is_tx_fltr = false; 5892 5893 if (promisc_mask & ICE_PROMISC_UCAST_RX) { 5894 promisc_mask &= ~ICE_PROMISC_UCAST_RX; 5895 pkt_type = UCAST_FLTR; 5896 } else if (promisc_mask & ICE_PROMISC_UCAST_TX) { 5897 promisc_mask &= ~ICE_PROMISC_UCAST_TX; 5898 pkt_type = UCAST_FLTR; 5899 is_tx_fltr = true; 5900 } else if (promisc_mask & ICE_PROMISC_MCAST_RX) { 5901 promisc_mask &= ~ICE_PROMISC_MCAST_RX; 5902 pkt_type = MCAST_FLTR; 5903 } else if (promisc_mask & ICE_PROMISC_MCAST_TX) { 5904 promisc_mask &= ~ICE_PROMISC_MCAST_TX; 5905 pkt_type = MCAST_FLTR; 5906 is_tx_fltr = true; 5907 } else if (promisc_mask & ICE_PROMISC_BCAST_RX) { 5908 promisc_mask &= ~ICE_PROMISC_BCAST_RX; 5909 pkt_type = BCAST_FLTR; 5910 } else if (promisc_mask & ICE_PROMISC_BCAST_TX) { 5911 promisc_mask &= ~ICE_PROMISC_BCAST_TX; 5912 pkt_type = BCAST_FLTR; 5913 is_tx_fltr = true; 5914 } 5915 5916 /* Check for VLAN promiscuous flag */ 5917 if (promisc_mask & ICE_PROMISC_VLAN_RX) { 5918 promisc_mask &= ~ICE_PROMISC_VLAN_RX; 5919 } else if (promisc_mask & ICE_PROMISC_VLAN_TX) { 5920 promisc_mask &= ~ICE_PROMISC_VLAN_TX; 5921 is_tx_fltr = true; 5922 } 5923 5924 /* Set filter DA based on packet type */ 5925 mac_addr = new_fltr.l_data.mac.mac_addr; 5926 if (pkt_type == BCAST_FLTR) { 5927 ice_memset(mac_addr, 0xff, ETH_ALEN, ICE_NONDMA_MEM); 5928 } else if (pkt_type == MCAST_FLTR || 5929 pkt_type == UCAST_FLTR) { 5930 /* Use the dummy ether header DA */ 5931 ice_memcpy(mac_addr, dummy_eth_header, ETH_ALEN, 5932 ICE_NONDMA_TO_NONDMA); 5933 if (pkt_type == MCAST_FLTR) 5934 mac_addr[0] |= 0x1; /* Set multicast bit */ 5935 } 5936 5937 /* Need to reset this to zero for all iterations */ 5938 new_fltr.flag = 0; 5939 if (is_tx_fltr) { 5940 new_fltr.flag |= ICE_FLTR_TX; 5941 new_fltr.src = hw_vsi_id; 5942 } else { 5943 new_fltr.flag |= ICE_FLTR_RX; 5944 new_fltr.src = lport; 5945 } 5946 5947 new_fltr.fltr_act = ICE_FWD_TO_VSI; 5948 new_fltr.vsi_handle = vsi_handle; 5949 new_fltr.fwd_id.hw_vsi_id = hw_vsi_id; 5950 f_list_entry.fltr_info = new_fltr; 5951 recp_list = &sw->recp_list[recipe_id]; 5952 5953 status = ice_add_rule_internal(hw, recp_list, lport, 5954 &f_list_entry); 5955 if (status != ICE_SUCCESS) 5956 goto set_promisc_exit; 5957 } 5958 5959 set_promisc_exit: 5960 return status; 5961 } 5962 5963 /** 5964 * ice_set_vsi_promisc - set given VSI to given promiscuous mode(s) 5965 * @hw: pointer to the hardware structure 5966 * @vsi_handle: VSI handle to configure 5967 * @promisc_mask: mask of promiscuous config bits 5968 * @vid: VLAN ID to set VLAN promiscuous 5969 */ 5970 enum ice_status 5971 ice_set_vsi_promisc(struct ice_hw *hw, u16 vsi_handle, u8 promisc_mask, 5972 u16 vid) 5973 { 5974 return _ice_set_vsi_promisc(hw, vsi_handle, promisc_mask, vid, 5975 hw->port_info->lport, 5976 hw->switch_info); 5977 } 5978 5979 /** 5980 * _ice_set_vlan_vsi_promisc 5981 * @hw: pointer to the hardware structure 5982 * @vsi_handle: VSI handle to configure 5983 * @promisc_mask: mask of promiscuous config bits 5984 * @rm_vlan_promisc: Clear VLANs VSI promisc mode 5985 * @lport: logical port number to configure promisc mode 5986 * @sw: pointer to switch info struct for which function add rule 5987 * 5988 * Configure VSI with all associated VLANs to given promiscuous mode(s) 5989 */ 5990 static enum ice_status 5991 _ice_set_vlan_vsi_promisc(struct ice_hw *hw, u16 vsi_handle, u8 promisc_mask, 5992 bool rm_vlan_promisc, u8 lport, 5993 struct ice_switch_info *sw) 5994 { 5995 struct ice_fltr_list_entry *list_itr, *tmp; 5996 struct LIST_HEAD_TYPE vsi_list_head; 5997 struct LIST_HEAD_TYPE *vlan_head; 5998 struct ice_lock *vlan_lock; /* Lock to protect filter rule list */ 5999 enum ice_status status; 6000 u16 vlan_id; 6001 6002 INIT_LIST_HEAD(&vsi_list_head); 6003 vlan_lock = &sw->recp_list[ICE_SW_LKUP_VLAN].filt_rule_lock; 6004 vlan_head = &sw->recp_list[ICE_SW_LKUP_VLAN].filt_rules; 6005 ice_acquire_lock(vlan_lock); 6006 status = ice_add_to_vsi_fltr_list(hw, vsi_handle, vlan_head, 6007 &vsi_list_head); 6008 ice_release_lock(vlan_lock); 6009 if (status) 6010 goto free_fltr_list; 6011 6012 LIST_FOR_EACH_ENTRY(list_itr, &vsi_list_head, ice_fltr_list_entry, 6013 list_entry) { 6014 vlan_id = list_itr->fltr_info.l_data.vlan.vlan_id; 6015 if (rm_vlan_promisc) 6016 status = _ice_clear_vsi_promisc(hw, vsi_handle, 6017 promisc_mask, 6018 vlan_id, sw); 6019 else 6020 status = _ice_set_vsi_promisc(hw, vsi_handle, 6021 promisc_mask, vlan_id, 6022 lport, sw); 6023 if (status) 6024 break; 6025 } 6026 6027 free_fltr_list: 6028 LIST_FOR_EACH_ENTRY_SAFE(list_itr, tmp, &vsi_list_head, 6029 ice_fltr_list_entry, list_entry) { 6030 LIST_DEL(&list_itr->list_entry); 6031 ice_free(hw, list_itr); 6032 } 6033 return status; 6034 } 6035 6036 /** 6037 * ice_set_vlan_vsi_promisc 6038 * @hw: pointer to the hardware structure 6039 * @vsi_handle: VSI handle to configure 6040 * @promisc_mask: mask of promiscuous config bits 6041 * @rm_vlan_promisc: Clear VLANs VSI promisc mode 6042 * 6043 * Configure VSI with all associated VLANs to given promiscuous mode(s) 6044 */ 6045 enum ice_status 6046 ice_set_vlan_vsi_promisc(struct ice_hw *hw, u16 vsi_handle, u8 promisc_mask, 6047 bool rm_vlan_promisc) 6048 { 6049 return _ice_set_vlan_vsi_promisc(hw, vsi_handle, promisc_mask, 6050 rm_vlan_promisc, hw->port_info->lport, 6051 hw->switch_info); 6052 } 6053 6054 /** 6055 * ice_remove_vsi_lkup_fltr - Remove lookup type filters for a VSI 6056 * @hw: pointer to the hardware structure 6057 * @vsi_handle: VSI handle to remove filters from 6058 * @recp_list: recipe list from which function remove fltr 6059 * @lkup: switch rule filter lookup type 6060 */ 6061 static void 6062 ice_remove_vsi_lkup_fltr(struct ice_hw *hw, u16 vsi_handle, 6063 struct ice_sw_recipe *recp_list, 6064 enum ice_sw_lkup_type lkup) 6065 { 6066 struct ice_fltr_list_entry *fm_entry; 6067 struct LIST_HEAD_TYPE remove_list_head; 6068 struct LIST_HEAD_TYPE *rule_head; 6069 struct ice_fltr_list_entry *tmp; 6070 struct ice_lock *rule_lock; /* Lock to protect filter rule list */ 6071 enum ice_status status; 6072 6073 INIT_LIST_HEAD(&remove_list_head); 6074 rule_lock = &recp_list[lkup].filt_rule_lock; 6075 rule_head = &recp_list[lkup].filt_rules; 6076 ice_acquire_lock(rule_lock); 6077 status = ice_add_to_vsi_fltr_list(hw, vsi_handle, rule_head, 6078 &remove_list_head); 6079 ice_release_lock(rule_lock); 6080 if (status) 6081 goto free_fltr_list; 6082 6083 switch (lkup) { 6084 case ICE_SW_LKUP_MAC: 6085 ice_remove_mac_rule(hw, &remove_list_head, &recp_list[lkup]); 6086 break; 6087 case ICE_SW_LKUP_VLAN: 6088 ice_remove_vlan_rule(hw, &remove_list_head, &recp_list[lkup]); 6089 break; 6090 case ICE_SW_LKUP_PROMISC: 6091 case ICE_SW_LKUP_PROMISC_VLAN: 6092 ice_remove_promisc(hw, lkup, &remove_list_head); 6093 break; 6094 case ICE_SW_LKUP_MAC_VLAN: 6095 ice_remove_mac_vlan(hw, &remove_list_head); 6096 break; 6097 case ICE_SW_LKUP_ETHERTYPE: 6098 case ICE_SW_LKUP_ETHERTYPE_MAC: 6099 ice_remove_eth_mac(hw, &remove_list_head); 6100 break; 6101 case ICE_SW_LKUP_DFLT: 6102 ice_debug(hw, ICE_DBG_SW, "Remove filters for this lookup type hasn't been implemented yet\n"); 6103 break; 6104 case ICE_SW_LKUP_LAST: 6105 ice_debug(hw, ICE_DBG_SW, "Unsupported lookup type\n"); 6106 break; 6107 } 6108 6109 free_fltr_list: 6110 LIST_FOR_EACH_ENTRY_SAFE(fm_entry, tmp, &remove_list_head, 6111 ice_fltr_list_entry, list_entry) { 6112 LIST_DEL(&fm_entry->list_entry); 6113 ice_free(hw, fm_entry); 6114 } 6115 } 6116 6117 /** 6118 * ice_remove_vsi_fltr_rule - Remove all filters for a VSI 6119 * @hw: pointer to the hardware structure 6120 * @vsi_handle: VSI handle to remove filters from 6121 * @sw: pointer to switch info struct 6122 */ 6123 static void 6124 ice_remove_vsi_fltr_rule(struct ice_hw *hw, u16 vsi_handle, 6125 struct ice_switch_info *sw) 6126 { 6127 ice_debug(hw, ICE_DBG_TRACE, "%s\n", __func__); 6128 6129 ice_remove_vsi_lkup_fltr(hw, vsi_handle, 6130 sw->recp_list, ICE_SW_LKUP_MAC); 6131 ice_remove_vsi_lkup_fltr(hw, vsi_handle, 6132 sw->recp_list, ICE_SW_LKUP_MAC_VLAN); 6133 ice_remove_vsi_lkup_fltr(hw, vsi_handle, 6134 sw->recp_list, ICE_SW_LKUP_PROMISC); 6135 ice_remove_vsi_lkup_fltr(hw, vsi_handle, 6136 sw->recp_list, ICE_SW_LKUP_VLAN); 6137 ice_remove_vsi_lkup_fltr(hw, vsi_handle, 6138 sw->recp_list, ICE_SW_LKUP_DFLT); 6139 ice_remove_vsi_lkup_fltr(hw, vsi_handle, 6140 sw->recp_list, ICE_SW_LKUP_ETHERTYPE); 6141 ice_remove_vsi_lkup_fltr(hw, vsi_handle, 6142 sw->recp_list, ICE_SW_LKUP_ETHERTYPE_MAC); 6143 ice_remove_vsi_lkup_fltr(hw, vsi_handle, 6144 sw->recp_list, ICE_SW_LKUP_PROMISC_VLAN); 6145 } 6146 6147 /** 6148 * ice_remove_vsi_fltr - Remove all filters for a VSI 6149 * @hw: pointer to the hardware structure 6150 * @vsi_handle: VSI handle to remove filters from 6151 */ 6152 void ice_remove_vsi_fltr(struct ice_hw *hw, u16 vsi_handle) 6153 { 6154 ice_remove_vsi_fltr_rule(hw, vsi_handle, hw->switch_info); 6155 } 6156 6157 /** 6158 * ice_alloc_res_cntr - allocating resource counter 6159 * @hw: pointer to the hardware structure 6160 * @type: type of resource 6161 * @alloc_shared: if set it is shared else dedicated 6162 * @num_items: number of entries requested for FD resource type 6163 * @counter_id: counter index returned by AQ call 6164 */ 6165 enum ice_status 6166 ice_alloc_res_cntr(struct ice_hw *hw, u8 type, u8 alloc_shared, u16 num_items, 6167 u16 *counter_id) 6168 { 6169 struct ice_aqc_alloc_free_res_elem *buf; 6170 enum ice_status status; 6171 u16 buf_len; 6172 6173 /* Allocate resource */ 6174 buf_len = ice_struct_size(buf, elem, 1); 6175 buf = (struct ice_aqc_alloc_free_res_elem *)ice_malloc(hw, buf_len); 6176 if (!buf) 6177 return ICE_ERR_NO_MEMORY; 6178 6179 buf->num_elems = CPU_TO_LE16(num_items); 6180 buf->res_type = CPU_TO_LE16(((type << ICE_AQC_RES_TYPE_S) & 6181 ICE_AQC_RES_TYPE_M) | alloc_shared); 6182 6183 status = ice_aq_alloc_free_res(hw, 1, buf, buf_len, 6184 ice_aqc_opc_alloc_res, NULL); 6185 if (status) 6186 goto exit; 6187 6188 *counter_id = LE16_TO_CPU(buf->elem[0].e.sw_resp); 6189 6190 exit: 6191 ice_free(hw, buf); 6192 return status; 6193 } 6194 6195 /** 6196 * ice_free_res_cntr - free resource counter 6197 * @hw: pointer to the hardware structure 6198 * @type: type of resource 6199 * @alloc_shared: if set it is shared else dedicated 6200 * @num_items: number of entries to be freed for FD resource type 6201 * @counter_id: counter ID resource which needs to be freed 6202 */ 6203 enum ice_status 6204 ice_free_res_cntr(struct ice_hw *hw, u8 type, u8 alloc_shared, u16 num_items, 6205 u16 counter_id) 6206 { 6207 struct ice_aqc_alloc_free_res_elem *buf; 6208 enum ice_status status; 6209 u16 buf_len; 6210 6211 /* Free resource */ 6212 buf_len = ice_struct_size(buf, elem, 1); 6213 buf = (struct ice_aqc_alloc_free_res_elem *)ice_malloc(hw, buf_len); 6214 if (!buf) 6215 return ICE_ERR_NO_MEMORY; 6216 6217 buf->num_elems = CPU_TO_LE16(num_items); 6218 buf->res_type = CPU_TO_LE16(((type << ICE_AQC_RES_TYPE_S) & 6219 ICE_AQC_RES_TYPE_M) | alloc_shared); 6220 buf->elem[0].e.sw_resp = CPU_TO_LE16(counter_id); 6221 6222 status = ice_aq_alloc_free_res(hw, 1, buf, buf_len, 6223 ice_aqc_opc_free_res, NULL); 6224 if (status) 6225 ice_debug(hw, ICE_DBG_SW, "counter resource could not be freed\n"); 6226 6227 ice_free(hw, buf); 6228 return status; 6229 } 6230 6231 /** 6232 * ice_alloc_vlan_res_counter - obtain counter resource for VLAN type 6233 * @hw: pointer to the hardware structure 6234 * @counter_id: returns counter index 6235 */ 6236 enum ice_status ice_alloc_vlan_res_counter(struct ice_hw *hw, u16 *counter_id) 6237 { 6238 return ice_alloc_res_cntr(hw, ICE_AQC_RES_TYPE_VLAN_COUNTER, 6239 ICE_AQC_RES_TYPE_FLAG_DEDICATED, 1, 6240 counter_id); 6241 } 6242 6243 /** 6244 * ice_free_vlan_res_counter - Free counter resource for VLAN type 6245 * @hw: pointer to the hardware structure 6246 * @counter_id: counter index to be freed 6247 */ 6248 enum ice_status ice_free_vlan_res_counter(struct ice_hw *hw, u16 counter_id) 6249 { 6250 return ice_free_res_cntr(hw, ICE_AQC_RES_TYPE_VLAN_COUNTER, 6251 ICE_AQC_RES_TYPE_FLAG_DEDICATED, 1, 6252 counter_id); 6253 } 6254 6255 /** 6256 * ice_alloc_res_lg_act - add large action resource 6257 * @hw: pointer to the hardware structure 6258 * @l_id: large action ID to fill it in 6259 * @num_acts: number of actions to hold with a large action entry 6260 */ 6261 static enum ice_status 6262 ice_alloc_res_lg_act(struct ice_hw *hw, u16 *l_id, u16 num_acts) 6263 { 6264 struct ice_aqc_alloc_free_res_elem *sw_buf; 6265 enum ice_status status; 6266 u16 buf_len; 6267 6268 if (num_acts > ICE_MAX_LG_ACT || num_acts == 0) 6269 return ICE_ERR_PARAM; 6270 6271 /* Allocate resource for large action */ 6272 buf_len = ice_struct_size(sw_buf, elem, 1); 6273 sw_buf = (struct ice_aqc_alloc_free_res_elem *)ice_malloc(hw, buf_len); 6274 if (!sw_buf) 6275 return ICE_ERR_NO_MEMORY; 6276 6277 sw_buf->num_elems = CPU_TO_LE16(1); 6278 6279 /* If num_acts is 1, use ICE_AQC_RES_TYPE_WIDE_TABLE_1. 6280 * If num_acts is 2, use ICE_AQC_RES_TYPE_WIDE_TABLE_3. 6281 * If num_acts is greater than 2, then use 6282 * ICE_AQC_RES_TYPE_WIDE_TABLE_4. 6283 * The num_acts cannot exceed 4. This was ensured at the 6284 * beginning of the function. 6285 */ 6286 if (num_acts == 1) 6287 sw_buf->res_type = CPU_TO_LE16(ICE_AQC_RES_TYPE_WIDE_TABLE_1); 6288 else if (num_acts == 2) 6289 sw_buf->res_type = CPU_TO_LE16(ICE_AQC_RES_TYPE_WIDE_TABLE_2); 6290 else 6291 sw_buf->res_type = CPU_TO_LE16(ICE_AQC_RES_TYPE_WIDE_TABLE_4); 6292 6293 status = ice_aq_alloc_free_res(hw, 1, sw_buf, buf_len, 6294 ice_aqc_opc_alloc_res, NULL); 6295 if (!status) 6296 *l_id = LE16_TO_CPU(sw_buf->elem[0].e.sw_resp); 6297 6298 ice_free(hw, sw_buf); 6299 return status; 6300 } 6301 6302 /** 6303 * ice_add_mac_with_sw_marker - add filter with sw marker 6304 * @hw: pointer to the hardware structure 6305 * @f_info: filter info structure containing the MAC filter information 6306 * @sw_marker: sw marker to tag the Rx descriptor with 6307 */ 6308 enum ice_status 6309 ice_add_mac_with_sw_marker(struct ice_hw *hw, struct ice_fltr_info *f_info, 6310 u16 sw_marker) 6311 { 6312 struct ice_fltr_mgmt_list_entry *m_entry; 6313 struct ice_fltr_list_entry fl_info; 6314 struct ice_sw_recipe *recp_list; 6315 struct LIST_HEAD_TYPE l_head; 6316 struct ice_lock *rule_lock; /* Lock to protect filter rule list */ 6317 enum ice_status ret; 6318 bool entry_exists; 6319 u16 lg_act_id; 6320 6321 if (f_info->fltr_act != ICE_FWD_TO_VSI) 6322 return ICE_ERR_PARAM; 6323 6324 if (f_info->lkup_type != ICE_SW_LKUP_MAC) 6325 return ICE_ERR_PARAM; 6326 6327 if (sw_marker == ICE_INVAL_SW_MARKER_ID) 6328 return ICE_ERR_PARAM; 6329 6330 if (!ice_is_vsi_valid(hw, f_info->vsi_handle)) 6331 return ICE_ERR_PARAM; 6332 f_info->fwd_id.hw_vsi_id = ice_get_hw_vsi_num(hw, f_info->vsi_handle); 6333 6334 /* Add filter if it doesn't exist so then the adding of large 6335 * action always results in update 6336 */ 6337 6338 INIT_LIST_HEAD(&l_head); 6339 fl_info.fltr_info = *f_info; 6340 LIST_ADD(&fl_info.list_entry, &l_head); 6341 6342 entry_exists = false; 6343 ret = ice_add_mac_rule(hw, &l_head, hw->switch_info, 6344 hw->port_info->lport); 6345 if (ret == ICE_ERR_ALREADY_EXISTS) 6346 entry_exists = true; 6347 else if (ret) 6348 return ret; 6349 6350 recp_list = &hw->switch_info->recp_list[ICE_SW_LKUP_MAC]; 6351 rule_lock = &recp_list->filt_rule_lock; 6352 ice_acquire_lock(rule_lock); 6353 /* Get the book keeping entry for the filter */ 6354 m_entry = ice_find_rule_entry(&recp_list->filt_rules, f_info); 6355 if (!m_entry) 6356 goto exit_error; 6357 6358 /* If counter action was enabled for this rule then don't enable 6359 * sw marker large action 6360 */ 6361 if (m_entry->counter_index != ICE_INVAL_COUNTER_ID) { 6362 ret = ICE_ERR_PARAM; 6363 goto exit_error; 6364 } 6365 6366 /* if same marker was added before */ 6367 if (m_entry->sw_marker_id == sw_marker) { 6368 ret = ICE_ERR_ALREADY_EXISTS; 6369 goto exit_error; 6370 } 6371 6372 /* Allocate a hardware table entry to hold large act. Three actions 6373 * for marker based large action 6374 */ 6375 ret = ice_alloc_res_lg_act(hw, &lg_act_id, 3); 6376 if (ret) 6377 goto exit_error; 6378 6379 if (lg_act_id == ICE_INVAL_LG_ACT_INDEX) 6380 goto exit_error; 6381 6382 /* Update the switch rule to add the marker action */ 6383 ret = ice_add_marker_act(hw, m_entry, sw_marker, lg_act_id); 6384 if (!ret) { 6385 ice_release_lock(rule_lock); 6386 return ret; 6387 } 6388 6389 exit_error: 6390 ice_release_lock(rule_lock); 6391 /* only remove entry if it did not exist previously */ 6392 if (!entry_exists) 6393 ret = ice_remove_mac(hw, &l_head); 6394 6395 return ret; 6396 } 6397 6398 /** 6399 * ice_add_mac_with_counter - add filter with counter enabled 6400 * @hw: pointer to the hardware structure 6401 * @f_info: pointer to filter info structure containing the MAC filter 6402 * information 6403 */ 6404 enum ice_status 6405 ice_add_mac_with_counter(struct ice_hw *hw, struct ice_fltr_info *f_info) 6406 { 6407 struct ice_fltr_mgmt_list_entry *m_entry; 6408 struct ice_fltr_list_entry fl_info; 6409 struct ice_sw_recipe *recp_list; 6410 struct LIST_HEAD_TYPE l_head; 6411 struct ice_lock *rule_lock; /* Lock to protect filter rule list */ 6412 enum ice_status ret; 6413 bool entry_exist; 6414 u16 counter_id; 6415 u16 lg_act_id; 6416 6417 if (f_info->fltr_act != ICE_FWD_TO_VSI) 6418 return ICE_ERR_PARAM; 6419 6420 if (f_info->lkup_type != ICE_SW_LKUP_MAC) 6421 return ICE_ERR_PARAM; 6422 6423 if (!ice_is_vsi_valid(hw, f_info->vsi_handle)) 6424 return ICE_ERR_PARAM; 6425 f_info->fwd_id.hw_vsi_id = ice_get_hw_vsi_num(hw, f_info->vsi_handle); 6426 recp_list = &hw->switch_info->recp_list[ICE_SW_LKUP_MAC]; 6427 6428 entry_exist = false; 6429 6430 rule_lock = &recp_list->filt_rule_lock; 6431 6432 /* Add filter if it doesn't exist so then the adding of large 6433 * action always results in update 6434 */ 6435 INIT_LIST_HEAD(&l_head); 6436 6437 fl_info.fltr_info = *f_info; 6438 LIST_ADD(&fl_info.list_entry, &l_head); 6439 6440 ret = ice_add_mac_rule(hw, &l_head, hw->switch_info, 6441 hw->port_info->lport); 6442 if (ret == ICE_ERR_ALREADY_EXISTS) 6443 entry_exist = true; 6444 else if (ret) 6445 return ret; 6446 6447 ice_acquire_lock(rule_lock); 6448 m_entry = ice_find_rule_entry(&recp_list->filt_rules, f_info); 6449 if (!m_entry) { 6450 ret = ICE_ERR_BAD_PTR; 6451 goto exit_error; 6452 } 6453 6454 /* Don't enable counter for a filter for which sw marker was enabled */ 6455 if (m_entry->sw_marker_id != ICE_INVAL_SW_MARKER_ID) { 6456 ret = ICE_ERR_PARAM; 6457 goto exit_error; 6458 } 6459 6460 /* If a counter was already enabled then don't need to add again */ 6461 if (m_entry->counter_index != ICE_INVAL_COUNTER_ID) { 6462 ret = ICE_ERR_ALREADY_EXISTS; 6463 goto exit_error; 6464 } 6465 6466 /* Allocate a hardware table entry to VLAN counter */ 6467 ret = ice_alloc_vlan_res_counter(hw, &counter_id); 6468 if (ret) 6469 goto exit_error; 6470 6471 /* Allocate a hardware table entry to hold large act. Two actions for 6472 * counter based large action 6473 */ 6474 ret = ice_alloc_res_lg_act(hw, &lg_act_id, 2); 6475 if (ret) 6476 goto exit_error; 6477 6478 if (lg_act_id == ICE_INVAL_LG_ACT_INDEX) 6479 goto exit_error; 6480 6481 /* Update the switch rule to add the counter action */ 6482 ret = ice_add_counter_act(hw, m_entry, counter_id, lg_act_id); 6483 if (!ret) { 6484 ice_release_lock(rule_lock); 6485 return ret; 6486 } 6487 6488 exit_error: 6489 ice_release_lock(rule_lock); 6490 /* only remove entry if it did not exist previously */ 6491 if (!entry_exist) 6492 ret = ice_remove_mac(hw, &l_head); 6493 6494 return ret; 6495 } 6496 6497 /* This is mapping table entry that maps every word within a given protocol 6498 * structure to the real byte offset as per the specification of that 6499 * protocol header. 6500 * for example dst address is 3 words in ethertype header and corresponding 6501 * bytes are 0, 2, 3 in the actual packet header and src address is at 4, 6, 8 6502 * IMPORTANT: Every structure part of "ice_prot_hdr" union should have a 6503 * matching entry describing its field. This needs to be updated if new 6504 * structure is added to that union. 6505 */ 6506 static const struct ice_prot_ext_tbl_entry ice_prot_ext[ICE_PROTOCOL_LAST] = { 6507 { ICE_MAC_OFOS, { 0, 2, 4, 6, 8, 10, 12 } }, 6508 { ICE_MAC_IL, { 0, 2, 4, 6, 8, 10, 12 } }, 6509 { ICE_ETYPE_OL, { 0 } }, 6510 { ICE_VLAN_OFOS, { 0, 2 } }, 6511 { ICE_IPV4_OFOS, { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18 } }, 6512 { ICE_IPV4_IL, { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18 } }, 6513 { ICE_IPV6_OFOS, { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 6514 26, 28, 30, 32, 34, 36, 38 } }, 6515 { ICE_IPV6_IL, { 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 6516 26, 28, 30, 32, 34, 36, 38 } }, 6517 { ICE_TCP_IL, { 0, 2 } }, 6518 { ICE_UDP_OF, { 0, 2 } }, 6519 { ICE_UDP_ILOS, { 0, 2 } }, 6520 { ICE_SCTP_IL, { 0, 2 } }, 6521 { ICE_VXLAN, { 8, 10, 12, 14 } }, 6522 { ICE_GENEVE, { 8, 10, 12, 14 } }, 6523 { ICE_VXLAN_GPE, { 8, 10, 12, 14 } }, 6524 { ICE_NVGRE, { 0, 2, 4, 6 } }, 6525 { ICE_GTP, { 8, 10, 12, 14, 16, 18, 20 } }, 6526 { ICE_PPPOE, { 0, 2, 4, 6 } }, 6527 { ICE_PFCP, { 8, 10, 12, 14, 16, 18, 20, 22 } }, 6528 { ICE_L2TPV3, { 0, 2, 4, 6, 8, 10 } }, 6529 { ICE_ESP, { 0, 2, 4, 6 } }, 6530 { ICE_AH, { 0, 2, 4, 6, 8, 10 } }, 6531 { ICE_NAT_T, { 8, 10, 12, 14 } }, 6532 { ICE_GTP_NO_PAY, { 8, 10, 12, 14 } }, 6533 { ICE_VLAN_EX, { 0, 2 } }, 6534 }; 6535 6536 /* The following table describes preferred grouping of recipes. 6537 * If a recipe that needs to be programmed is a superset or matches one of the 6538 * following combinations, then the recipe needs to be chained as per the 6539 * following policy. 6540 */ 6541 6542 static const struct ice_protocol_entry ice_prot_id_tbl[ICE_PROTOCOL_LAST] = { 6543 { ICE_MAC_OFOS, ICE_MAC_OFOS_HW }, 6544 { ICE_MAC_IL, ICE_MAC_IL_HW }, 6545 { ICE_ETYPE_OL, ICE_ETYPE_OL_HW }, 6546 { ICE_VLAN_OFOS, ICE_VLAN_OL_HW }, 6547 { ICE_IPV4_OFOS, ICE_IPV4_OFOS_HW }, 6548 { ICE_IPV4_IL, ICE_IPV4_IL_HW }, 6549 { ICE_IPV6_OFOS, ICE_IPV6_OFOS_HW }, 6550 { ICE_IPV6_IL, ICE_IPV6_IL_HW }, 6551 { ICE_TCP_IL, ICE_TCP_IL_HW }, 6552 { ICE_UDP_OF, ICE_UDP_OF_HW }, 6553 { ICE_UDP_ILOS, ICE_UDP_ILOS_HW }, 6554 { ICE_SCTP_IL, ICE_SCTP_IL_HW }, 6555 { ICE_VXLAN, ICE_UDP_OF_HW }, 6556 { ICE_GENEVE, ICE_UDP_OF_HW }, 6557 { ICE_VXLAN_GPE, ICE_UDP_OF_HW }, 6558 { ICE_NVGRE, ICE_GRE_OF_HW }, 6559 { ICE_GTP, ICE_UDP_OF_HW }, 6560 { ICE_PPPOE, ICE_PPPOE_HW }, 6561 { ICE_PFCP, ICE_UDP_ILOS_HW }, 6562 { ICE_L2TPV3, ICE_L2TPV3_HW }, 6563 { ICE_ESP, ICE_ESP_HW }, 6564 { ICE_AH, ICE_AH_HW }, 6565 { ICE_NAT_T, ICE_UDP_ILOS_HW }, 6566 { ICE_GTP_NO_PAY, ICE_UDP_ILOS_HW }, 6567 { ICE_VLAN_EX, ICE_VLAN_OF_HW }, 6568 }; 6569 6570 /** 6571 * ice_find_recp - find a recipe 6572 * @hw: pointer to the hardware structure 6573 * @lkup_exts: extension sequence to match 6574 * 6575 * Returns index of matching recipe, or ICE_MAX_NUM_RECIPES if not found. 6576 */ 6577 static u16 ice_find_recp(struct ice_hw *hw, struct ice_prot_lkup_ext *lkup_exts, 6578 enum ice_sw_tunnel_type tun_type) 6579 { 6580 bool refresh_required = true; 6581 struct ice_sw_recipe *recp; 6582 u8 i; 6583 6584 /* Walk through existing recipes to find a match */ 6585 recp = hw->switch_info->recp_list; 6586 for (i = 0; i < ICE_MAX_NUM_RECIPES; i++) { 6587 /* If recipe was not created for this ID, in SW bookkeeping, 6588 * check if FW has an entry for this recipe. If the FW has an 6589 * entry update it in our SW bookkeeping and continue with the 6590 * matching. 6591 */ 6592 if (!recp[i].recp_created) 6593 if (ice_get_recp_frm_fw(hw, 6594 hw->switch_info->recp_list, i, 6595 &refresh_required)) 6596 continue; 6597 6598 /* Skip inverse action recipes */ 6599 if (recp[i].root_buf && recp[i].root_buf->content.act_ctrl & 6600 ICE_AQ_RECIPE_ACT_INV_ACT) 6601 continue; 6602 6603 /* if number of words we are looking for match */ 6604 if (lkup_exts->n_val_words == recp[i].lkup_exts.n_val_words) { 6605 struct ice_fv_word *ar = recp[i].lkup_exts.fv_words; 6606 struct ice_fv_word *be = lkup_exts->fv_words; 6607 u16 *cr = recp[i].lkup_exts.field_mask; 6608 u16 *de = lkup_exts->field_mask; 6609 bool found = true; 6610 u8 pe, qr; 6611 6612 /* ar, cr, and qr are related to the recipe words, while 6613 * be, de, and pe are related to the lookup words 6614 */ 6615 for (pe = 0; pe < lkup_exts->n_val_words; pe++) { 6616 for (qr = 0; qr < recp[i].lkup_exts.n_val_words; 6617 qr++) { 6618 if (ar[qr].off == be[pe].off && 6619 ar[qr].prot_id == be[pe].prot_id && 6620 cr[qr] == de[pe]) 6621 /* Found the "pe"th word in the 6622 * given recipe 6623 */ 6624 break; 6625 } 6626 /* After walking through all the words in the 6627 * "i"th recipe if "p"th word was not found then 6628 * this recipe is not what we are looking for. 6629 * So break out from this loop and try the next 6630 * recipe 6631 */ 6632 if (qr >= recp[i].lkup_exts.n_val_words) { 6633 found = false; 6634 break; 6635 } 6636 } 6637 /* If for "i"th recipe the found was never set to false 6638 * then it means we found our match 6639 */ 6640 if (tun_type == recp[i].tun_type && found) 6641 return i; /* Return the recipe ID */ 6642 } 6643 } 6644 return ICE_MAX_NUM_RECIPES; 6645 } 6646 6647 /** 6648 * ice_prot_type_to_id - get protocol ID from protocol type 6649 * @type: protocol type 6650 * @id: pointer to variable that will receive the ID 6651 * 6652 * Returns true if found, false otherwise 6653 */ 6654 static bool ice_prot_type_to_id(enum ice_protocol_type type, u8 *id) 6655 { 6656 u8 i; 6657 6658 for (i = 0; i < ARRAY_SIZE(ice_prot_id_tbl); i++) 6659 if (ice_prot_id_tbl[i].type == type) { 6660 *id = ice_prot_id_tbl[i].protocol_id; 6661 return true; 6662 } 6663 return false; 6664 } 6665 6666 /** 6667 * ice_find_valid_words - count valid words 6668 * @rule: advanced rule with lookup information 6669 * @lkup_exts: byte offset extractions of the words that are valid 6670 * 6671 * calculate valid words in a lookup rule using mask value 6672 */ 6673 static u8 6674 ice_fill_valid_words(struct ice_adv_lkup_elem *rule, 6675 struct ice_prot_lkup_ext *lkup_exts) 6676 { 6677 u8 j, word, prot_id, ret_val; 6678 6679 if (!ice_prot_type_to_id(rule->type, &prot_id)) 6680 return 0; 6681 6682 word = lkup_exts->n_val_words; 6683 6684 for (j = 0; j < sizeof(rule->m_u) / sizeof(u16); j++) 6685 if (((u16 *)&rule->m_u)[j] && 6686 (size_t)rule->type < ARRAY_SIZE(ice_prot_ext)) { 6687 /* No more space to accommodate */ 6688 if (word >= ICE_MAX_CHAIN_WORDS) 6689 return 0; 6690 lkup_exts->fv_words[word].off = 6691 ice_prot_ext[rule->type].offs[j]; 6692 lkup_exts->fv_words[word].prot_id = 6693 ice_prot_id_tbl[rule->type].protocol_id; 6694 lkup_exts->field_mask[word] = 6695 BE16_TO_CPU(((_FORCE_ __be16 *)&rule->m_u)[j]); 6696 word++; 6697 } 6698 6699 ret_val = word - lkup_exts->n_val_words; 6700 lkup_exts->n_val_words = word; 6701 6702 return ret_val; 6703 } 6704 6705 /** 6706 * ice_create_first_fit_recp_def - Create a recipe grouping 6707 * @hw: pointer to the hardware structure 6708 * @lkup_exts: an array of protocol header extractions 6709 * @rg_list: pointer to a list that stores new recipe groups 6710 * @recp_cnt: pointer to a variable that stores returned number of recipe groups 6711 * 6712 * Using first fit algorithm, take all the words that are still not done 6713 * and start grouping them in 4-word groups. Each group makes up one 6714 * recipe. 6715 */ 6716 static enum ice_status 6717 ice_create_first_fit_recp_def(struct ice_hw *hw, 6718 struct ice_prot_lkup_ext *lkup_exts, 6719 struct LIST_HEAD_TYPE *rg_list, 6720 u8 *recp_cnt) 6721 { 6722 struct ice_pref_recipe_group *grp = NULL; 6723 u8 j; 6724 6725 *recp_cnt = 0; 6726 6727 if (!lkup_exts->n_val_words) { 6728 struct ice_recp_grp_entry *entry; 6729 6730 entry = (struct ice_recp_grp_entry *) 6731 ice_malloc(hw, sizeof(*entry)); 6732 if (!entry) 6733 return ICE_ERR_NO_MEMORY; 6734 LIST_ADD(&entry->l_entry, rg_list); 6735 grp = &entry->r_group; 6736 (*recp_cnt)++; 6737 grp->n_val_pairs = 0; 6738 } 6739 6740 /* Walk through every word in the rule to check if it is not done. If so 6741 * then this word needs to be part of a new recipe. 6742 */ 6743 for (j = 0; j < lkup_exts->n_val_words; j++) 6744 if (!ice_is_bit_set(lkup_exts->done, j)) { 6745 if (!grp || 6746 grp->n_val_pairs == ICE_NUM_WORDS_RECIPE) { 6747 struct ice_recp_grp_entry *entry; 6748 6749 entry = (struct ice_recp_grp_entry *) 6750 ice_malloc(hw, sizeof(*entry)); 6751 if (!entry) 6752 return ICE_ERR_NO_MEMORY; 6753 LIST_ADD(&entry->l_entry, rg_list); 6754 grp = &entry->r_group; 6755 (*recp_cnt)++; 6756 } 6757 6758 grp->pairs[grp->n_val_pairs].prot_id = 6759 lkup_exts->fv_words[j].prot_id; 6760 grp->pairs[grp->n_val_pairs].off = 6761 lkup_exts->fv_words[j].off; 6762 grp->mask[grp->n_val_pairs] = lkup_exts->field_mask[j]; 6763 grp->n_val_pairs++; 6764 } 6765 6766 return ICE_SUCCESS; 6767 } 6768 6769 /** 6770 * ice_fill_fv_word_index - fill in the field vector indices for a recipe group 6771 * @hw: pointer to the hardware structure 6772 * @fv_list: field vector with the extraction sequence information 6773 * @rg_list: recipe groupings with protocol-offset pairs 6774 * 6775 * Helper function to fill in the field vector indices for protocol-offset 6776 * pairs. These indexes are then ultimately programmed into a recipe. 6777 */ 6778 static enum ice_status 6779 ice_fill_fv_word_index(struct ice_hw *hw, struct LIST_HEAD_TYPE *fv_list, 6780 struct LIST_HEAD_TYPE *rg_list) 6781 { 6782 struct ice_sw_fv_list_entry *fv; 6783 struct ice_recp_grp_entry *rg; 6784 struct ice_fv_word *fv_ext; 6785 6786 if (LIST_EMPTY(fv_list)) 6787 return ICE_SUCCESS; 6788 6789 fv = LIST_FIRST_ENTRY(fv_list, struct ice_sw_fv_list_entry, list_entry); 6790 fv_ext = fv->fv_ptr->ew; 6791 6792 LIST_FOR_EACH_ENTRY(rg, rg_list, ice_recp_grp_entry, l_entry) { 6793 u8 i; 6794 6795 for (i = 0; i < rg->r_group.n_val_pairs; i++) { 6796 struct ice_fv_word *pr; 6797 bool found = false; 6798 u16 mask; 6799 u8 j; 6800 6801 pr = &rg->r_group.pairs[i]; 6802 mask = rg->r_group.mask[i]; 6803 6804 for (j = 0; j < hw->blk[ICE_BLK_SW].es.fvw; j++) 6805 if (fv_ext[j].prot_id == pr->prot_id && 6806 fv_ext[j].off == pr->off) { 6807 found = true; 6808 6809 /* Store index of field vector */ 6810 rg->fv_idx[i] = j; 6811 rg->fv_mask[i] = mask; 6812 break; 6813 } 6814 6815 /* Protocol/offset could not be found, caller gave an 6816 * invalid pair 6817 */ 6818 if (!found) 6819 return ICE_ERR_PARAM; 6820 } 6821 } 6822 6823 return ICE_SUCCESS; 6824 } 6825 6826 /** 6827 * ice_find_free_recp_res_idx - find free result indexes for recipe 6828 * @hw: pointer to hardware structure 6829 * @profiles: bitmap of profiles that will be associated with the new recipe 6830 * @free_idx: pointer to variable to receive the free index bitmap 6831 * 6832 * The algorithm used here is: 6833 * 1. When creating a new recipe, create a set P which contains all 6834 * Profiles that will be associated with our new recipe 6835 * 6836 * 2. For each Profile p in set P: 6837 * a. Add all recipes associated with Profile p into set R 6838 * b. Optional : PossibleIndexes &= profile[p].possibleIndexes 6839 * [initially PossibleIndexes should be 0xFFFFFFFFFFFFFFFF] 6840 * i. Or just assume they all have the same possible indexes: 6841 * 44, 45, 46, 47 6842 * i.e., PossibleIndexes = 0x0000F00000000000 6843 * 6844 * 3. For each Recipe r in set R: 6845 * a. UsedIndexes |= (bitwise or ) recipe[r].res_indexes 6846 * b. FreeIndexes = UsedIndexes ^ PossibleIndexes 6847 * 6848 * FreeIndexes will contain the bits indicating the indexes free for use, 6849 * then the code needs to update the recipe[r].used_result_idx_bits to 6850 * indicate which indexes were selected for use by this recipe. 6851 */ 6852 static u16 6853 ice_find_free_recp_res_idx(struct ice_hw *hw, const ice_bitmap_t *profiles, 6854 ice_bitmap_t *free_idx) 6855 { 6856 ice_declare_bitmap(possible_idx, ICE_MAX_FV_WORDS); 6857 ice_declare_bitmap(recipes, ICE_MAX_NUM_RECIPES); 6858 ice_declare_bitmap(used_idx, ICE_MAX_FV_WORDS); 6859 u16 bit; 6860 6861 ice_zero_bitmap(possible_idx, ICE_MAX_FV_WORDS); 6862 ice_zero_bitmap(recipes, ICE_MAX_NUM_RECIPES); 6863 ice_zero_bitmap(used_idx, ICE_MAX_FV_WORDS); 6864 ice_zero_bitmap(free_idx, ICE_MAX_FV_WORDS); 6865 6866 ice_bitmap_set(possible_idx, 0, ICE_MAX_FV_WORDS); 6867 6868 /* For each profile we are going to associate the recipe with, add the 6869 * recipes that are associated with that profile. This will give us 6870 * the set of recipes that our recipe may collide with. Also, determine 6871 * what possible result indexes are usable given this set of profiles. 6872 */ 6873 ice_for_each_set_bit(bit, profiles, ICE_MAX_NUM_PROFILES) { 6874 ice_or_bitmap(recipes, recipes, profile_to_recipe[bit], 6875 ICE_MAX_NUM_RECIPES); 6876 ice_and_bitmap(possible_idx, possible_idx, 6877 hw->switch_info->prof_res_bm[bit], 6878 ICE_MAX_FV_WORDS); 6879 } 6880 6881 /* For each recipe that our new recipe may collide with, determine 6882 * which indexes have been used. 6883 */ 6884 ice_for_each_set_bit(bit, recipes, ICE_MAX_NUM_RECIPES) 6885 ice_or_bitmap(used_idx, used_idx, 6886 hw->switch_info->recp_list[bit].res_idxs, 6887 ICE_MAX_FV_WORDS); 6888 6889 ice_xor_bitmap(free_idx, used_idx, possible_idx, ICE_MAX_FV_WORDS); 6890 6891 /* return number of free indexes */ 6892 return (u16)ice_bitmap_hweight(free_idx, ICE_MAX_FV_WORDS); 6893 } 6894 6895 /** 6896 * ice_add_sw_recipe - function to call AQ calls to create switch recipe 6897 * @hw: pointer to hardware structure 6898 * @rm: recipe management list entry 6899 * @profiles: bitmap of profiles that will be associated. 6900 */ 6901 static enum ice_status 6902 ice_add_sw_recipe(struct ice_hw *hw, struct ice_sw_recipe *rm, 6903 ice_bitmap_t *profiles) 6904 { 6905 ice_declare_bitmap(result_idx_bm, ICE_MAX_FV_WORDS); 6906 struct ice_aqc_recipe_data_elem *tmp; 6907 struct ice_aqc_recipe_data_elem *buf; 6908 struct ice_recp_grp_entry *entry; 6909 enum ice_status status; 6910 u16 free_res_idx; 6911 u16 recipe_count; 6912 u8 chain_idx; 6913 u8 recps = 0; 6914 6915 /* When more than one recipe are required, another recipe is needed to 6916 * chain them together. Matching a tunnel metadata ID takes up one of 6917 * the match fields in the chaining recipe reducing the number of 6918 * chained recipes by one. 6919 */ 6920 /* check number of free result indices */ 6921 ice_zero_bitmap(result_idx_bm, ICE_MAX_FV_WORDS); 6922 free_res_idx = ice_find_free_recp_res_idx(hw, profiles, result_idx_bm); 6923 6924 ice_debug(hw, ICE_DBG_SW, "Result idx slots: %d, need %d\n", 6925 free_res_idx, rm->n_grp_count); 6926 6927 if (rm->n_grp_count > 1) { 6928 if (rm->n_grp_count > free_res_idx) 6929 return ICE_ERR_MAX_LIMIT; 6930 6931 rm->n_grp_count++; 6932 } 6933 6934 if (rm->n_grp_count > ICE_MAX_CHAIN_RECIPE) 6935 return ICE_ERR_MAX_LIMIT; 6936 6937 tmp = (struct ice_aqc_recipe_data_elem *)ice_calloc(hw, 6938 ICE_MAX_NUM_RECIPES, 6939 sizeof(*tmp)); 6940 if (!tmp) 6941 return ICE_ERR_NO_MEMORY; 6942 6943 buf = (struct ice_aqc_recipe_data_elem *) 6944 ice_calloc(hw, rm->n_grp_count, sizeof(*buf)); 6945 if (!buf) { 6946 status = ICE_ERR_NO_MEMORY; 6947 goto err_mem; 6948 } 6949 6950 ice_zero_bitmap(rm->r_bitmap, ICE_MAX_NUM_RECIPES); 6951 recipe_count = ICE_MAX_NUM_RECIPES; 6952 status = ice_aq_get_recipe(hw, tmp, &recipe_count, ICE_SW_LKUP_MAC, 6953 NULL); 6954 if (status || recipe_count == 0) 6955 goto err_unroll; 6956 6957 /* Allocate the recipe resources, and configure them according to the 6958 * match fields from protocol headers and extracted field vectors. 6959 */ 6960 chain_idx = ice_find_first_bit(result_idx_bm, ICE_MAX_FV_WORDS); 6961 LIST_FOR_EACH_ENTRY(entry, &rm->rg_list, ice_recp_grp_entry, l_entry) { 6962 u8 i; 6963 6964 status = ice_alloc_recipe(hw, &entry->rid); 6965 if (status) 6966 goto err_unroll; 6967 6968 /* Clear the result index of the located recipe, as this will be 6969 * updated, if needed, later in the recipe creation process. 6970 */ 6971 tmp[0].content.result_indx = 0; 6972 6973 buf[recps] = tmp[0]; 6974 buf[recps].recipe_indx = (u8)entry->rid; 6975 /* if the recipe is a non-root recipe RID should be programmed 6976 * as 0 for the rules to be applied correctly. 6977 */ 6978 buf[recps].content.rid = 0; 6979 ice_memset(&buf[recps].content.lkup_indx, 0, 6980 sizeof(buf[recps].content.lkup_indx), 6981 ICE_NONDMA_MEM); 6982 6983 /* All recipes use look-up index 0 to match switch ID. */ 6984 buf[recps].content.lkup_indx[0] = ICE_AQ_SW_ID_LKUP_IDX; 6985 buf[recps].content.mask[0] = 6986 CPU_TO_LE16(ICE_AQ_SW_ID_LKUP_MASK); 6987 /* Setup lkup_indx 1..4 to INVALID/ignore and set the mask 6988 * to be 0 6989 */ 6990 for (i = 1; i <= ICE_NUM_WORDS_RECIPE; i++) { 6991 buf[recps].content.lkup_indx[i] = 0x80; 6992 buf[recps].content.mask[i] = 0; 6993 } 6994 6995 for (i = 0; i < entry->r_group.n_val_pairs; i++) { 6996 buf[recps].content.lkup_indx[i + 1] = entry->fv_idx[i]; 6997 buf[recps].content.mask[i + 1] = 6998 CPU_TO_LE16(entry->fv_mask[i]); 6999 } 7000 7001 if (rm->n_grp_count > 1) { 7002 /* Checks to see if there really is a valid result index 7003 * that can be used. 7004 */ 7005 if (chain_idx >= ICE_MAX_FV_WORDS) { 7006 ice_debug(hw, ICE_DBG_SW, "No chain index available\n"); 7007 status = ICE_ERR_MAX_LIMIT; 7008 goto err_unroll; 7009 } 7010 7011 entry->chain_idx = chain_idx; 7012 buf[recps].content.result_indx = 7013 ICE_AQ_RECIPE_RESULT_EN | 7014 ((chain_idx << ICE_AQ_RECIPE_RESULT_DATA_S) & 7015 ICE_AQ_RECIPE_RESULT_DATA_M); 7016 ice_clear_bit(chain_idx, result_idx_bm); 7017 chain_idx = ice_find_first_bit(result_idx_bm, 7018 ICE_MAX_FV_WORDS); 7019 } 7020 7021 /* fill recipe dependencies */ 7022 ice_zero_bitmap((ice_bitmap_t *)buf[recps].recipe_bitmap, 7023 ICE_MAX_NUM_RECIPES); 7024 ice_set_bit(buf[recps].recipe_indx, 7025 (ice_bitmap_t *)buf[recps].recipe_bitmap); 7026 buf[recps].content.act_ctrl_fwd_priority = rm->priority; 7027 recps++; 7028 } 7029 7030 if (rm->n_grp_count == 1) { 7031 rm->root_rid = buf[0].recipe_indx; 7032 ice_set_bit(buf[0].recipe_indx, rm->r_bitmap); 7033 buf[0].content.rid = rm->root_rid | ICE_AQ_RECIPE_ID_IS_ROOT; 7034 if (sizeof(buf[0].recipe_bitmap) >= sizeof(rm->r_bitmap)) { 7035 ice_memcpy(buf[0].recipe_bitmap, rm->r_bitmap, 7036 sizeof(buf[0].recipe_bitmap), 7037 ICE_NONDMA_TO_NONDMA); 7038 } else { 7039 status = ICE_ERR_BAD_PTR; 7040 goto err_unroll; 7041 } 7042 /* Applicable only for ROOT_RECIPE, set the fwd_priority for 7043 * the recipe which is getting created if specified 7044 * by user. Usually any advanced switch filter, which results 7045 * into new extraction sequence, ended up creating a new recipe 7046 * of type ROOT and usually recipes are associated with profiles 7047 * Switch rule referreing newly created recipe, needs to have 7048 * either/or 'fwd' or 'join' priority, otherwise switch rule 7049 * evaluation will not happen correctly. In other words, if 7050 * switch rule to be evaluated on priority basis, then recipe 7051 * needs to have priority, otherwise it will be evaluated last. 7052 */ 7053 buf[0].content.act_ctrl_fwd_priority = rm->priority; 7054 } else { 7055 struct ice_recp_grp_entry *last_chain_entry; 7056 u16 rid, i; 7057 7058 /* Allocate the last recipe that will chain the outcomes of the 7059 * other recipes together 7060 */ 7061 status = ice_alloc_recipe(hw, &rid); 7062 if (status) 7063 goto err_unroll; 7064 7065 buf[recps].recipe_indx = (u8)rid; 7066 buf[recps].content.rid = (u8)rid; 7067 buf[recps].content.rid |= ICE_AQ_RECIPE_ID_IS_ROOT; 7068 /* the new entry created should also be part of rg_list to 7069 * make sure we have complete recipe 7070 */ 7071 last_chain_entry = (struct ice_recp_grp_entry *)ice_malloc(hw, 7072 sizeof(*last_chain_entry)); 7073 if (!last_chain_entry) { 7074 status = ICE_ERR_NO_MEMORY; 7075 goto err_unroll; 7076 } 7077 last_chain_entry->rid = rid; 7078 ice_memset(&buf[recps].content.lkup_indx, 0, 7079 sizeof(buf[recps].content.lkup_indx), 7080 ICE_NONDMA_MEM); 7081 /* All recipes use look-up index 0 to match switch ID. */ 7082 buf[recps].content.lkup_indx[0] = ICE_AQ_SW_ID_LKUP_IDX; 7083 buf[recps].content.mask[0] = 7084 CPU_TO_LE16(ICE_AQ_SW_ID_LKUP_MASK); 7085 for (i = 1; i <= ICE_NUM_WORDS_RECIPE; i++) { 7086 buf[recps].content.lkup_indx[i] = 7087 ICE_AQ_RECIPE_LKUP_IGNORE; 7088 buf[recps].content.mask[i] = 0; 7089 } 7090 7091 i = 1; 7092 /* update r_bitmap with the recp that is used for chaining */ 7093 ice_set_bit(rid, rm->r_bitmap); 7094 /* this is the recipe that chains all the other recipes so it 7095 * should not have a chaining ID to indicate the same 7096 */ 7097 last_chain_entry->chain_idx = ICE_INVAL_CHAIN_IND; 7098 LIST_FOR_EACH_ENTRY(entry, &rm->rg_list, ice_recp_grp_entry, 7099 l_entry) { 7100 last_chain_entry->fv_idx[i] = entry->chain_idx; 7101 buf[recps].content.lkup_indx[i] = entry->chain_idx; 7102 buf[recps].content.mask[i++] = CPU_TO_LE16(0xFFFF); 7103 ice_set_bit(entry->rid, rm->r_bitmap); 7104 } 7105 LIST_ADD(&last_chain_entry->l_entry, &rm->rg_list); 7106 if (sizeof(buf[recps].recipe_bitmap) >= 7107 sizeof(rm->r_bitmap)) { 7108 ice_memcpy(buf[recps].recipe_bitmap, rm->r_bitmap, 7109 sizeof(buf[recps].recipe_bitmap), 7110 ICE_NONDMA_TO_NONDMA); 7111 } else { 7112 status = ICE_ERR_BAD_PTR; 7113 goto err_unroll; 7114 } 7115 buf[recps].content.act_ctrl_fwd_priority = rm->priority; 7116 7117 recps++; 7118 rm->root_rid = (u8)rid; 7119 } 7120 status = ice_acquire_change_lock(hw, ICE_RES_WRITE); 7121 if (status) 7122 goto err_unroll; 7123 7124 status = ice_aq_add_recipe(hw, buf, rm->n_grp_count, NULL); 7125 ice_release_change_lock(hw); 7126 if (status) 7127 goto err_unroll; 7128 7129 /* Every recipe that just got created add it to the recipe 7130 * book keeping list 7131 */ 7132 LIST_FOR_EACH_ENTRY(entry, &rm->rg_list, ice_recp_grp_entry, l_entry) { 7133 struct ice_switch_info *sw = hw->switch_info; 7134 bool is_root, idx_found = false; 7135 struct ice_sw_recipe *recp; 7136 u16 idx, buf_idx = 0; 7137 7138 /* find buffer index for copying some data */ 7139 for (idx = 0; idx < rm->n_grp_count; idx++) 7140 if (buf[idx].recipe_indx == entry->rid) { 7141 buf_idx = idx; 7142 idx_found = true; 7143 } 7144 7145 if (!idx_found) { 7146 status = ICE_ERR_OUT_OF_RANGE; 7147 goto err_unroll; 7148 } 7149 7150 recp = &sw->recp_list[entry->rid]; 7151 is_root = (rm->root_rid == entry->rid); 7152 recp->is_root = is_root; 7153 7154 recp->root_rid = entry->rid; 7155 recp->big_recp = (is_root && rm->n_grp_count > 1); 7156 7157 ice_memcpy(&recp->ext_words, entry->r_group.pairs, 7158 entry->r_group.n_val_pairs * 7159 sizeof(struct ice_fv_word), 7160 ICE_NONDMA_TO_NONDMA); 7161 7162 ice_memcpy(recp->r_bitmap, buf[buf_idx].recipe_bitmap, 7163 sizeof(recp->r_bitmap), ICE_NONDMA_TO_NONDMA); 7164 7165 /* Copy non-result fv index values and masks to recipe. This 7166 * call will also update the result recipe bitmask. 7167 */ 7168 ice_collect_result_idx(&buf[buf_idx], recp); 7169 7170 /* for non-root recipes, also copy to the root, this allows 7171 * easier matching of a complete chained recipe 7172 */ 7173 if (!is_root) 7174 ice_collect_result_idx(&buf[buf_idx], 7175 &sw->recp_list[rm->root_rid]); 7176 7177 recp->n_ext_words = entry->r_group.n_val_pairs; 7178 recp->chain_idx = entry->chain_idx; 7179 recp->priority = buf[buf_idx].content.act_ctrl_fwd_priority; 7180 recp->n_grp_count = rm->n_grp_count; 7181 recp->tun_type = rm->tun_type; 7182 recp->recp_created = true; 7183 } 7184 rm->root_buf = buf; 7185 ice_free(hw, tmp); 7186 return status; 7187 7188 err_unroll: 7189 err_mem: 7190 ice_free(hw, tmp); 7191 ice_free(hw, buf); 7192 return status; 7193 } 7194 7195 /** 7196 * ice_create_recipe_group - creates recipe group 7197 * @hw: pointer to hardware structure 7198 * @rm: recipe management list entry 7199 * @lkup_exts: lookup elements 7200 */ 7201 static enum ice_status 7202 ice_create_recipe_group(struct ice_hw *hw, struct ice_sw_recipe *rm, 7203 struct ice_prot_lkup_ext *lkup_exts) 7204 { 7205 enum ice_status status; 7206 u8 recp_count = 0; 7207 7208 rm->n_grp_count = 0; 7209 7210 /* Create recipes for words that are marked not done by packing them 7211 * as best fit. 7212 */ 7213 status = ice_create_first_fit_recp_def(hw, lkup_exts, 7214 &rm->rg_list, &recp_count); 7215 if (!status) { 7216 rm->n_grp_count += recp_count; 7217 rm->n_ext_words = lkup_exts->n_val_words; 7218 ice_memcpy(&rm->ext_words, lkup_exts->fv_words, 7219 sizeof(rm->ext_words), ICE_NONDMA_TO_NONDMA); 7220 ice_memcpy(rm->word_masks, lkup_exts->field_mask, 7221 sizeof(rm->word_masks), ICE_NONDMA_TO_NONDMA); 7222 } 7223 7224 return status; 7225 } 7226 7227 /** 7228 * ice_get_fv - get field vectors/extraction sequences for spec. lookup types 7229 * @hw: pointer to hardware structure 7230 * @lkups: lookup elements or match criteria for the advanced recipe, one 7231 * structure per protocol header 7232 * @lkups_cnt: number of protocols 7233 * @bm: bitmap of field vectors to consider 7234 * @fv_list: pointer to a list that holds the returned field vectors 7235 */ 7236 static enum ice_status 7237 ice_get_fv(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, u16 lkups_cnt, 7238 ice_bitmap_t *bm, struct LIST_HEAD_TYPE *fv_list) 7239 { 7240 enum ice_status status; 7241 u8 *prot_ids; 7242 u16 i; 7243 7244 if (!lkups_cnt) 7245 return ICE_SUCCESS; 7246 7247 prot_ids = (u8 *)ice_calloc(hw, lkups_cnt, sizeof(*prot_ids)); 7248 if (!prot_ids) 7249 return ICE_ERR_NO_MEMORY; 7250 7251 for (i = 0; i < lkups_cnt; i++) 7252 if (!ice_prot_type_to_id(lkups[i].type, &prot_ids[i])) { 7253 status = ICE_ERR_CFG; 7254 goto free_mem; 7255 } 7256 7257 /* Find field vectors that include all specified protocol types */ 7258 status = ice_get_sw_fv_list(hw, prot_ids, lkups_cnt, bm, fv_list); 7259 7260 free_mem: 7261 ice_free(hw, prot_ids); 7262 return status; 7263 } 7264 7265 /** 7266 * ice_tun_type_match_mask - determine if tun type needs a match mask 7267 * @tun_type: tunnel type 7268 * @mask: mask to be used for the tunnel 7269 */ 7270 static bool ice_tun_type_match_word(enum ice_sw_tunnel_type tun_type, u16 *mask) 7271 { 7272 switch (tun_type) { 7273 case ICE_SW_TUN_VXLAN_GPE: 7274 case ICE_SW_TUN_GENEVE: 7275 case ICE_SW_TUN_VXLAN: 7276 case ICE_SW_TUN_NVGRE: 7277 case ICE_SW_TUN_UDP: 7278 case ICE_ALL_TUNNELS: 7279 case ICE_SW_TUN_AND_NON_TUN_QINQ: 7280 case ICE_NON_TUN_QINQ: 7281 case ICE_SW_TUN_PPPOE_QINQ: 7282 case ICE_SW_TUN_PPPOE_PAY_QINQ: 7283 case ICE_SW_TUN_PPPOE_IPV4_QINQ: 7284 case ICE_SW_TUN_PPPOE_IPV6_QINQ: 7285 *mask = ICE_TUN_FLAG_MASK; 7286 return true; 7287 7288 case ICE_SW_TUN_GENEVE_VLAN: 7289 case ICE_SW_TUN_VXLAN_VLAN: 7290 *mask = ICE_TUN_FLAG_MASK & ~ICE_TUN_FLAG_VLAN_MASK; 7291 return true; 7292 7293 default: 7294 *mask = 0; 7295 return false; 7296 } 7297 } 7298 7299 /** 7300 * ice_add_special_words - Add words that are not protocols, such as metadata 7301 * @rinfo: other information regarding the rule e.g. priority and action info 7302 * @lkup_exts: lookup word structure 7303 */ 7304 static enum ice_status 7305 ice_add_special_words(struct ice_adv_rule_info *rinfo, 7306 struct ice_prot_lkup_ext *lkup_exts) 7307 { 7308 u16 mask; 7309 7310 /* If this is a tunneled packet, then add recipe index to match the 7311 * tunnel bit in the packet metadata flags. 7312 */ 7313 if (ice_tun_type_match_word(rinfo->tun_type, &mask)) { 7314 if (lkup_exts->n_val_words < ICE_MAX_CHAIN_WORDS) { 7315 u8 word = lkup_exts->n_val_words++; 7316 7317 lkup_exts->fv_words[word].prot_id = ICE_META_DATA_ID_HW; 7318 lkup_exts->fv_words[word].off = ICE_TUN_FLAG_MDID_OFF; 7319 lkup_exts->field_mask[word] = mask; 7320 } else { 7321 return ICE_ERR_MAX_LIMIT; 7322 } 7323 } 7324 7325 return ICE_SUCCESS; 7326 } 7327 7328 /* ice_get_compat_fv_bitmap - Get compatible field vector bitmap for rule 7329 * @hw: pointer to hardware structure 7330 * @rinfo: other information regarding the rule e.g. priority and action info 7331 * @bm: pointer to memory for returning the bitmap of field vectors 7332 */ 7333 static void 7334 ice_get_compat_fv_bitmap(struct ice_hw *hw, struct ice_adv_rule_info *rinfo, 7335 ice_bitmap_t *bm) 7336 { 7337 enum ice_prof_type prof_type; 7338 7339 ice_zero_bitmap(bm, ICE_MAX_NUM_PROFILES); 7340 7341 switch (rinfo->tun_type) { 7342 case ICE_NON_TUN: 7343 case ICE_NON_TUN_QINQ: 7344 prof_type = ICE_PROF_NON_TUN; 7345 break; 7346 case ICE_ALL_TUNNELS: 7347 prof_type = ICE_PROF_TUN_ALL; 7348 break; 7349 case ICE_SW_TUN_VXLAN_GPE: 7350 case ICE_SW_TUN_GENEVE: 7351 case ICE_SW_TUN_GENEVE_VLAN: 7352 case ICE_SW_TUN_VXLAN: 7353 case ICE_SW_TUN_VXLAN_VLAN: 7354 case ICE_SW_TUN_UDP: 7355 case ICE_SW_TUN_GTP: 7356 prof_type = ICE_PROF_TUN_UDP; 7357 break; 7358 case ICE_SW_TUN_NVGRE: 7359 prof_type = ICE_PROF_TUN_GRE; 7360 break; 7361 case ICE_SW_TUN_PPPOE: 7362 case ICE_SW_TUN_PPPOE_QINQ: 7363 prof_type = ICE_PROF_TUN_PPPOE; 7364 break; 7365 case ICE_SW_TUN_PPPOE_PAY: 7366 case ICE_SW_TUN_PPPOE_PAY_QINQ: 7367 ice_set_bit(ICE_PROFID_PPPOE_PAY, bm); 7368 return; 7369 case ICE_SW_TUN_PPPOE_IPV4: 7370 case ICE_SW_TUN_PPPOE_IPV4_QINQ: 7371 ice_set_bit(ICE_PROFID_PPPOE_IPV4_OTHER, bm); 7372 ice_set_bit(ICE_PROFID_PPPOE_IPV4_UDP, bm); 7373 ice_set_bit(ICE_PROFID_PPPOE_IPV4_TCP, bm); 7374 return; 7375 case ICE_SW_TUN_PPPOE_IPV4_TCP: 7376 ice_set_bit(ICE_PROFID_PPPOE_IPV4_TCP, bm); 7377 return; 7378 case ICE_SW_TUN_PPPOE_IPV4_UDP: 7379 ice_set_bit(ICE_PROFID_PPPOE_IPV4_UDP, bm); 7380 return; 7381 case ICE_SW_TUN_PPPOE_IPV6: 7382 case ICE_SW_TUN_PPPOE_IPV6_QINQ: 7383 ice_set_bit(ICE_PROFID_PPPOE_IPV6_OTHER, bm); 7384 ice_set_bit(ICE_PROFID_PPPOE_IPV6_UDP, bm); 7385 ice_set_bit(ICE_PROFID_PPPOE_IPV6_TCP, bm); 7386 return; 7387 case ICE_SW_TUN_PPPOE_IPV6_TCP: 7388 ice_set_bit(ICE_PROFID_PPPOE_IPV6_TCP, bm); 7389 return; 7390 case ICE_SW_TUN_PPPOE_IPV6_UDP: 7391 ice_set_bit(ICE_PROFID_PPPOE_IPV6_UDP, bm); 7392 return; 7393 case ICE_SW_TUN_PROFID_IPV6_ESP: 7394 case ICE_SW_TUN_IPV6_ESP: 7395 ice_set_bit(ICE_PROFID_IPV6_ESP, bm); 7396 return; 7397 case ICE_SW_TUN_PROFID_IPV6_AH: 7398 case ICE_SW_TUN_IPV6_AH: 7399 ice_set_bit(ICE_PROFID_IPV6_AH, bm); 7400 return; 7401 case ICE_SW_TUN_PROFID_MAC_IPV6_L2TPV3: 7402 case ICE_SW_TUN_IPV6_L2TPV3: 7403 ice_set_bit(ICE_PROFID_MAC_IPV6_L2TPV3, bm); 7404 return; 7405 case ICE_SW_TUN_PROFID_IPV6_NAT_T: 7406 case ICE_SW_TUN_IPV6_NAT_T: 7407 ice_set_bit(ICE_PROFID_IPV6_NAT_T, bm); 7408 return; 7409 case ICE_SW_TUN_PROFID_IPV4_PFCP_NODE: 7410 ice_set_bit(ICE_PROFID_IPV4_PFCP_NODE, bm); 7411 return; 7412 case ICE_SW_TUN_PROFID_IPV4_PFCP_SESSION: 7413 ice_set_bit(ICE_PROFID_IPV4_PFCP_SESSION, bm); 7414 return; 7415 case ICE_SW_TUN_PROFID_IPV6_PFCP_NODE: 7416 ice_set_bit(ICE_PROFID_IPV6_PFCP_NODE, bm); 7417 return; 7418 case ICE_SW_TUN_PROFID_IPV6_PFCP_SESSION: 7419 ice_set_bit(ICE_PROFID_IPV6_PFCP_SESSION, bm); 7420 return; 7421 case ICE_SW_TUN_IPV4_NAT_T: 7422 ice_set_bit(ICE_PROFID_IPV4_NAT_T, bm); 7423 return; 7424 case ICE_SW_TUN_IPV4_L2TPV3: 7425 ice_set_bit(ICE_PROFID_MAC_IPV4_L2TPV3, bm); 7426 return; 7427 case ICE_SW_TUN_IPV4_ESP: 7428 ice_set_bit(ICE_PROFID_IPV4_ESP, bm); 7429 return; 7430 case ICE_SW_TUN_IPV4_AH: 7431 ice_set_bit(ICE_PROFID_IPV4_AH, bm); 7432 return; 7433 case ICE_SW_IPV4_TCP: 7434 ice_set_bit(ICE_PROFID_IPV4_TCP, bm); 7435 return; 7436 case ICE_SW_IPV4_UDP: 7437 ice_set_bit(ICE_PROFID_IPV4_UDP, bm); 7438 return; 7439 case ICE_SW_IPV6_TCP: 7440 ice_set_bit(ICE_PROFID_IPV6_TCP, bm); 7441 return; 7442 case ICE_SW_IPV6_UDP: 7443 ice_set_bit(ICE_PROFID_IPV6_UDP, bm); 7444 return; 7445 case ICE_SW_TUN_IPV4_GTPU_IPV4: 7446 ice_set_bit(ICE_PROFID_IPV4_GTPU_EH_IPV4_OTHER, bm); 7447 ice_set_bit(ICE_PROFID_IPV4_GTPU_IPV4_OTHER, bm); 7448 ice_set_bit(ICE_PROFID_IPV4_GTPU_EH_IPV4_UDP, bm); 7449 ice_set_bit(ICE_PROFID_IPV4_GTPU_IPV4_UDP, bm); 7450 ice_set_bit(ICE_PROFID_IPV4_GTPU_EH_IPV4_TCP, bm); 7451 ice_set_bit(ICE_PROFID_IPV4_GTPU_IPV4_TCP, bm); 7452 return; 7453 case ICE_SW_TUN_IPV6_GTPU_IPV4: 7454 ice_set_bit(ICE_PROFID_IPV6_GTPU_EH_IPV4_OTHER, bm); 7455 ice_set_bit(ICE_PROFID_IPV6_GTPU_IPV4_OTHER, bm); 7456 ice_set_bit(ICE_PROFID_IPV6_GTPU_EH_IPV4_UDP, bm); 7457 ice_set_bit(ICE_PROFID_IPV6_GTPU_IPV4_UDP, bm); 7458 ice_set_bit(ICE_PROFID_IPV6_GTPU_EH_IPV4_TCP, bm); 7459 ice_set_bit(ICE_PROFID_IPV6_GTPU_IPV4_TCP, bm); 7460 return; 7461 case ICE_SW_TUN_IPV4_GTPU_IPV6: 7462 ice_set_bit(ICE_PROFID_IPV4_GTPU_EH_IPV6_OTHER, bm); 7463 ice_set_bit(ICE_PROFID_IPV4_GTPU_IPV6_OTHER, bm); 7464 ice_set_bit(ICE_PROFID_IPV4_GTPU_EH_IPV6_UDP, bm); 7465 ice_set_bit(ICE_PROFID_IPV4_GTPU_IPV6_UDP, bm); 7466 ice_set_bit(ICE_PROFID_IPV4_GTPU_EH_IPV6_TCP, bm); 7467 ice_set_bit(ICE_PROFID_IPV4_GTPU_IPV6_TCP, bm); 7468 return; 7469 case ICE_SW_TUN_IPV6_GTPU_IPV6: 7470 ice_set_bit(ICE_PROFID_IPV6_GTPU_EH_IPV6_OTHER, bm); 7471 ice_set_bit(ICE_PROFID_IPV6_GTPU_IPV6_OTHER, bm); 7472 ice_set_bit(ICE_PROFID_IPV6_GTPU_EH_IPV6_UDP, bm); 7473 ice_set_bit(ICE_PROFID_IPV6_GTPU_IPV6_UDP, bm); 7474 ice_set_bit(ICE_PROFID_IPV6_GTPU_EH_IPV6_TCP, bm); 7475 ice_set_bit(ICE_PROFID_IPV6_GTPU_IPV6_TCP, bm); 7476 return; 7477 case ICE_SW_TUN_AND_NON_TUN: 7478 case ICE_SW_TUN_AND_NON_TUN_QINQ: 7479 default: 7480 prof_type = ICE_PROF_ALL; 7481 break; 7482 } 7483 7484 ice_get_sw_fv_bitmap(hw, prof_type, bm); 7485 } 7486 7487 /** 7488 * ice_is_prof_rule - determine if rule type is a profile rule 7489 * @type: the rule type 7490 * 7491 * if the rule type is a profile rule, that means that there no field value 7492 * match required, in this case just a profile hit is required. 7493 */ 7494 bool ice_is_prof_rule(enum ice_sw_tunnel_type type) 7495 { 7496 switch (type) { 7497 case ICE_SW_TUN_PROFID_IPV6_ESP: 7498 case ICE_SW_TUN_PROFID_IPV6_AH: 7499 case ICE_SW_TUN_PROFID_MAC_IPV6_L2TPV3: 7500 case ICE_SW_TUN_PROFID_IPV6_NAT_T: 7501 case ICE_SW_TUN_PROFID_IPV4_PFCP_NODE: 7502 case ICE_SW_TUN_PROFID_IPV4_PFCP_SESSION: 7503 case ICE_SW_TUN_PROFID_IPV6_PFCP_NODE: 7504 case ICE_SW_TUN_PROFID_IPV6_PFCP_SESSION: 7505 return true; 7506 default: 7507 break; 7508 } 7509 7510 return false; 7511 } 7512 7513 /** 7514 * ice_add_adv_recipe - Add an advanced recipe that is not part of the default 7515 * @hw: pointer to hardware structure 7516 * @lkups: lookup elements or match criteria for the advanced recipe, one 7517 * structure per protocol header 7518 * @lkups_cnt: number of protocols 7519 * @rinfo: other information regarding the rule e.g. priority and action info 7520 * @rid: return the recipe ID of the recipe created 7521 */ 7522 static enum ice_status 7523 ice_add_adv_recipe(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, 7524 u16 lkups_cnt, struct ice_adv_rule_info *rinfo, u16 *rid) 7525 { 7526 ice_declare_bitmap(fv_bitmap, ICE_MAX_NUM_PROFILES); 7527 ice_declare_bitmap(profiles, ICE_MAX_NUM_PROFILES); 7528 struct ice_prot_lkup_ext *lkup_exts; 7529 struct ice_recp_grp_entry *r_entry; 7530 struct ice_sw_fv_list_entry *fvit; 7531 struct ice_recp_grp_entry *r_tmp; 7532 struct ice_sw_fv_list_entry *tmp; 7533 enum ice_status status = ICE_SUCCESS; 7534 struct ice_sw_recipe *rm; 7535 u8 i; 7536 7537 if (!ice_is_prof_rule(rinfo->tun_type) && !lkups_cnt) 7538 return ICE_ERR_PARAM; 7539 7540 lkup_exts = (struct ice_prot_lkup_ext *) 7541 ice_malloc(hw, sizeof(*lkup_exts)); 7542 if (!lkup_exts) 7543 return ICE_ERR_NO_MEMORY; 7544 7545 /* Determine the number of words to be matched and if it exceeds a 7546 * recipe's restrictions 7547 */ 7548 for (i = 0; i < lkups_cnt; i++) { 7549 u16 count; 7550 7551 if (lkups[i].type >= ICE_PROTOCOL_LAST) { 7552 status = ICE_ERR_CFG; 7553 goto err_free_lkup_exts; 7554 } 7555 7556 count = ice_fill_valid_words(&lkups[i], lkup_exts); 7557 if (!count) { 7558 status = ICE_ERR_CFG; 7559 goto err_free_lkup_exts; 7560 } 7561 } 7562 7563 rm = (struct ice_sw_recipe *)ice_malloc(hw, sizeof(*rm)); 7564 if (!rm) { 7565 status = ICE_ERR_NO_MEMORY; 7566 goto err_free_lkup_exts; 7567 } 7568 7569 /* Get field vectors that contain fields extracted from all the protocol 7570 * headers being programmed. 7571 */ 7572 INIT_LIST_HEAD(&rm->fv_list); 7573 INIT_LIST_HEAD(&rm->rg_list); 7574 7575 /* Get bitmap of field vectors (profiles) that are compatible with the 7576 * rule request; only these will be searched in the subsequent call to 7577 * ice_get_fv. 7578 */ 7579 ice_get_compat_fv_bitmap(hw, rinfo, fv_bitmap); 7580 7581 status = ice_get_fv(hw, lkups, lkups_cnt, fv_bitmap, &rm->fv_list); 7582 if (status) 7583 goto err_unroll; 7584 7585 /* Create any special protocol/offset pairs, such as looking at tunnel 7586 * bits by extracting metadata 7587 */ 7588 status = ice_add_special_words(rinfo, lkup_exts); 7589 if (status) 7590 goto err_free_lkup_exts; 7591 7592 /* Group match words into recipes using preferred recipe grouping 7593 * criteria. 7594 */ 7595 status = ice_create_recipe_group(hw, rm, lkup_exts); 7596 if (status) 7597 goto err_unroll; 7598 7599 /* set the recipe priority if specified */ 7600 rm->priority = (u8)rinfo->priority; 7601 7602 /* Find offsets from the field vector. Pick the first one for all the 7603 * recipes. 7604 */ 7605 status = ice_fill_fv_word_index(hw, &rm->fv_list, &rm->rg_list); 7606 if (status) 7607 goto err_unroll; 7608 7609 /* An empty FV list means to use all the profiles returned in the 7610 * profile bitmap 7611 */ 7612 if (LIST_EMPTY(&rm->fv_list)) { 7613 u16 j; 7614 7615 ice_for_each_set_bit(j, fv_bitmap, ICE_MAX_NUM_PROFILES) { 7616 struct ice_sw_fv_list_entry *fvl; 7617 7618 fvl = (struct ice_sw_fv_list_entry *) 7619 ice_malloc(hw, sizeof(*fvl)); 7620 if (!fvl) 7621 goto err_unroll; 7622 fvl->fv_ptr = NULL; 7623 fvl->profile_id = j; 7624 LIST_ADD(&fvl->list_entry, &rm->fv_list); 7625 } 7626 } 7627 7628 /* get bitmap of all profiles the recipe will be associated with */ 7629 ice_zero_bitmap(profiles, ICE_MAX_NUM_PROFILES); 7630 LIST_FOR_EACH_ENTRY(fvit, &rm->fv_list, ice_sw_fv_list_entry, 7631 list_entry) { 7632 ice_debug(hw, ICE_DBG_SW, "profile: %d\n", fvit->profile_id); 7633 ice_set_bit((u16)fvit->profile_id, profiles); 7634 } 7635 7636 /* Look for a recipe which matches our requested fv / mask list */ 7637 *rid = ice_find_recp(hw, lkup_exts, rinfo->tun_type); 7638 if (*rid < ICE_MAX_NUM_RECIPES) 7639 /* Success if found a recipe that match the existing criteria */ 7640 goto err_unroll; 7641 7642 rm->tun_type = rinfo->tun_type; 7643 /* Recipe we need does not exist, add a recipe */ 7644 status = ice_add_sw_recipe(hw, rm, profiles); 7645 if (status) 7646 goto err_unroll; 7647 7648 /* Associate all the recipes created with all the profiles in the 7649 * common field vector. 7650 */ 7651 LIST_FOR_EACH_ENTRY(fvit, &rm->fv_list, ice_sw_fv_list_entry, 7652 list_entry) { 7653 ice_declare_bitmap(r_bitmap, ICE_MAX_NUM_RECIPES); 7654 u16 j; 7655 7656 status = ice_aq_get_recipe_to_profile(hw, fvit->profile_id, 7657 (u8 *)r_bitmap, NULL); 7658 if (status) 7659 goto err_unroll; 7660 7661 ice_or_bitmap(r_bitmap, r_bitmap, rm->r_bitmap, 7662 ICE_MAX_NUM_RECIPES); 7663 status = ice_acquire_change_lock(hw, ICE_RES_WRITE); 7664 if (status) 7665 goto err_unroll; 7666 7667 status = ice_aq_map_recipe_to_profile(hw, fvit->profile_id, 7668 (u8 *)r_bitmap, 7669 NULL); 7670 ice_release_change_lock(hw); 7671 7672 if (status) 7673 goto err_unroll; 7674 7675 /* Update profile to recipe bitmap array */ 7676 ice_cp_bitmap(profile_to_recipe[fvit->profile_id], r_bitmap, 7677 ICE_MAX_NUM_RECIPES); 7678 7679 /* Update recipe to profile bitmap array */ 7680 ice_for_each_set_bit(j, rm->r_bitmap, ICE_MAX_NUM_RECIPES) 7681 ice_set_bit((u16)fvit->profile_id, 7682 recipe_to_profile[j]); 7683 } 7684 7685 *rid = rm->root_rid; 7686 ice_memcpy(&hw->switch_info->recp_list[*rid].lkup_exts, 7687 lkup_exts, sizeof(*lkup_exts), ICE_NONDMA_TO_NONDMA); 7688 err_unroll: 7689 LIST_FOR_EACH_ENTRY_SAFE(r_entry, r_tmp, &rm->rg_list, 7690 ice_recp_grp_entry, l_entry) { 7691 LIST_DEL(&r_entry->l_entry); 7692 ice_free(hw, r_entry); 7693 } 7694 7695 LIST_FOR_EACH_ENTRY_SAFE(fvit, tmp, &rm->fv_list, ice_sw_fv_list_entry, 7696 list_entry) { 7697 LIST_DEL(&fvit->list_entry); 7698 ice_free(hw, fvit); 7699 } 7700 7701 if (rm->root_buf) 7702 ice_free(hw, rm->root_buf); 7703 7704 ice_free(hw, rm); 7705 7706 err_free_lkup_exts: 7707 ice_free(hw, lkup_exts); 7708 7709 return status; 7710 } 7711 7712 /** 7713 * ice_find_dummy_packet - find dummy packet by tunnel type 7714 * 7715 * @lkups: lookup elements or match criteria for the advanced recipe, one 7716 * structure per protocol header 7717 * @lkups_cnt: number of protocols 7718 * @tun_type: tunnel type from the match criteria 7719 * @pkt: dummy packet to fill according to filter match criteria 7720 * @pkt_len: packet length of dummy packet 7721 * @offsets: pointer to receive the pointer to the offsets for the packet 7722 */ 7723 static void 7724 ice_find_dummy_packet(struct ice_adv_lkup_elem *lkups, u16 lkups_cnt, 7725 enum ice_sw_tunnel_type tun_type, const u8 **pkt, 7726 u16 *pkt_len, 7727 const struct ice_dummy_pkt_offsets **offsets) 7728 { 7729 bool tcp = false, udp = false, ipv6 = false, vlan = false; 7730 bool gre = false; 7731 u16 i; 7732 7733 for (i = 0; i < lkups_cnt; i++) { 7734 if (lkups[i].type == ICE_UDP_ILOS) 7735 udp = true; 7736 else if (lkups[i].type == ICE_TCP_IL) 7737 tcp = true; 7738 else if (lkups[i].type == ICE_IPV6_OFOS) 7739 ipv6 = true; 7740 else if (lkups[i].type == ICE_VLAN_OFOS) 7741 vlan = true; 7742 else if (lkups[i].type == ICE_IPV4_OFOS && 7743 lkups[i].h_u.ipv4_hdr.protocol == 7744 ICE_IPV4_NVGRE_PROTO_ID && 7745 lkups[i].m_u.ipv4_hdr.protocol == 7746 0xFF) 7747 gre = true; 7748 else if (lkups[i].type == ICE_PPPOE && 7749 lkups[i].h_u.pppoe_hdr.ppp_prot_id == 7750 CPU_TO_BE16(ICE_PPP_IPV6_PROTO_ID) && 7751 lkups[i].m_u.pppoe_hdr.ppp_prot_id == 7752 0xFFFF) 7753 ipv6 = true; 7754 else if (lkups[i].type == ICE_ETYPE_OL && 7755 lkups[i].h_u.ethertype.ethtype_id == 7756 CPU_TO_BE16(ICE_IPV6_ETHER_ID) && 7757 lkups[i].m_u.ethertype.ethtype_id == 7758 0xFFFF) 7759 ipv6 = true; 7760 else if (lkups[i].type == ICE_IPV4_IL && 7761 lkups[i].h_u.ipv4_hdr.protocol == 7762 ICE_TCP_PROTO_ID && 7763 lkups[i].m_u.ipv4_hdr.protocol == 7764 0xFF) 7765 tcp = true; 7766 } 7767 7768 if ((tun_type == ICE_SW_TUN_AND_NON_TUN_QINQ || 7769 tun_type == ICE_NON_TUN_QINQ) && ipv6) { 7770 *pkt = dummy_qinq_ipv6_pkt; 7771 *pkt_len = sizeof(dummy_qinq_ipv6_pkt); 7772 *offsets = dummy_qinq_ipv6_packet_offsets; 7773 return; 7774 } else if (tun_type == ICE_SW_TUN_AND_NON_TUN_QINQ || 7775 tun_type == ICE_NON_TUN_QINQ) { 7776 *pkt = dummy_qinq_ipv4_pkt; 7777 *pkt_len = sizeof(dummy_qinq_ipv4_pkt); 7778 *offsets = dummy_qinq_ipv4_packet_offsets; 7779 return; 7780 } 7781 7782 if (tun_type == ICE_SW_TUN_PPPOE_IPV6_QINQ) { 7783 *pkt = dummy_qinq_pppoe_ipv6_packet; 7784 *pkt_len = sizeof(dummy_qinq_pppoe_ipv6_packet); 7785 *offsets = dummy_qinq_pppoe_packet_ipv6_offsets; 7786 return; 7787 } else if (tun_type == ICE_SW_TUN_PPPOE_IPV4_QINQ) { 7788 *pkt = dummy_qinq_pppoe_ipv4_pkt; 7789 *pkt_len = sizeof(dummy_qinq_pppoe_ipv4_pkt); 7790 *offsets = dummy_qinq_pppoe_ipv4_packet_offsets; 7791 return; 7792 } else if (tun_type == ICE_SW_TUN_PPPOE_QINQ || 7793 tun_type == ICE_SW_TUN_PPPOE_PAY_QINQ) { 7794 *pkt = dummy_qinq_pppoe_ipv4_pkt; 7795 *pkt_len = sizeof(dummy_qinq_pppoe_ipv4_pkt); 7796 *offsets = dummy_qinq_pppoe_packet_offsets; 7797 return; 7798 } 7799 7800 if (tun_type == ICE_SW_TUN_IPV4_GTPU_NO_PAY) { 7801 *pkt = dummy_ipv4_gtpu_ipv4_packet; 7802 *pkt_len = sizeof(dummy_ipv4_gtpu_ipv4_packet); 7803 *offsets = dummy_ipv4_gtp_no_pay_packet_offsets; 7804 return; 7805 } else if (tun_type == ICE_SW_TUN_IPV6_GTPU_NO_PAY) { 7806 *pkt = dummy_ipv6_gtpu_ipv6_packet; 7807 *pkt_len = sizeof(dummy_ipv6_gtpu_ipv6_packet); 7808 *offsets = dummy_ipv6_gtp_no_pay_packet_offsets; 7809 return; 7810 } 7811 7812 if (tun_type == ICE_SW_TUN_IPV4_ESP) { 7813 *pkt = dummy_ipv4_esp_pkt; 7814 *pkt_len = sizeof(dummy_ipv4_esp_pkt); 7815 *offsets = dummy_ipv4_esp_packet_offsets; 7816 return; 7817 } 7818 7819 if (tun_type == ICE_SW_TUN_IPV6_ESP) { 7820 *pkt = dummy_ipv6_esp_pkt; 7821 *pkt_len = sizeof(dummy_ipv6_esp_pkt); 7822 *offsets = dummy_ipv6_esp_packet_offsets; 7823 return; 7824 } 7825 7826 if (tun_type == ICE_SW_TUN_IPV4_AH) { 7827 *pkt = dummy_ipv4_ah_pkt; 7828 *pkt_len = sizeof(dummy_ipv4_ah_pkt); 7829 *offsets = dummy_ipv4_ah_packet_offsets; 7830 return; 7831 } 7832 7833 if (tun_type == ICE_SW_TUN_IPV6_AH) { 7834 *pkt = dummy_ipv6_ah_pkt; 7835 *pkt_len = sizeof(dummy_ipv6_ah_pkt); 7836 *offsets = dummy_ipv6_ah_packet_offsets; 7837 return; 7838 } 7839 7840 if (tun_type == ICE_SW_TUN_IPV4_NAT_T) { 7841 *pkt = dummy_ipv4_nat_pkt; 7842 *pkt_len = sizeof(dummy_ipv4_nat_pkt); 7843 *offsets = dummy_ipv4_nat_packet_offsets; 7844 return; 7845 } 7846 7847 if (tun_type == ICE_SW_TUN_IPV6_NAT_T) { 7848 *pkt = dummy_ipv6_nat_pkt; 7849 *pkt_len = sizeof(dummy_ipv6_nat_pkt); 7850 *offsets = dummy_ipv6_nat_packet_offsets; 7851 return; 7852 } 7853 7854 if (tun_type == ICE_SW_TUN_IPV4_L2TPV3) { 7855 *pkt = dummy_ipv4_l2tpv3_pkt; 7856 *pkt_len = sizeof(dummy_ipv4_l2tpv3_pkt); 7857 *offsets = dummy_ipv4_l2tpv3_packet_offsets; 7858 return; 7859 } 7860 7861 if (tun_type == ICE_SW_TUN_IPV6_L2TPV3) { 7862 *pkt = dummy_ipv6_l2tpv3_pkt; 7863 *pkt_len = sizeof(dummy_ipv6_l2tpv3_pkt); 7864 *offsets = dummy_ipv6_l2tpv3_packet_offsets; 7865 return; 7866 } 7867 7868 if (tun_type == ICE_SW_TUN_GTP) { 7869 *pkt = dummy_udp_gtp_packet; 7870 *pkt_len = sizeof(dummy_udp_gtp_packet); 7871 *offsets = dummy_udp_gtp_packet_offsets; 7872 return; 7873 } 7874 7875 if (tun_type == ICE_SW_TUN_PPPOE && ipv6) { 7876 *pkt = dummy_pppoe_ipv6_packet; 7877 *pkt_len = sizeof(dummy_pppoe_ipv6_packet); 7878 *offsets = dummy_pppoe_packet_offsets; 7879 return; 7880 } else if (tun_type == ICE_SW_TUN_PPPOE || 7881 tun_type == ICE_SW_TUN_PPPOE_PAY) { 7882 *pkt = dummy_pppoe_ipv4_packet; 7883 *pkt_len = sizeof(dummy_pppoe_ipv4_packet); 7884 *offsets = dummy_pppoe_packet_offsets; 7885 return; 7886 } 7887 7888 if (tun_type == ICE_SW_TUN_PPPOE_IPV4) { 7889 *pkt = dummy_pppoe_ipv4_packet; 7890 *pkt_len = sizeof(dummy_pppoe_ipv4_packet); 7891 *offsets = dummy_pppoe_packet_ipv4_offsets; 7892 return; 7893 } 7894 7895 if (tun_type == ICE_SW_TUN_PPPOE_IPV4_TCP) { 7896 *pkt = dummy_pppoe_ipv4_tcp_packet; 7897 *pkt_len = sizeof(dummy_pppoe_ipv4_tcp_packet); 7898 *offsets = dummy_pppoe_ipv4_tcp_packet_offsets; 7899 return; 7900 } 7901 7902 if (tun_type == ICE_SW_TUN_PPPOE_IPV4_UDP) { 7903 *pkt = dummy_pppoe_ipv4_udp_packet; 7904 *pkt_len = sizeof(dummy_pppoe_ipv4_udp_packet); 7905 *offsets = dummy_pppoe_ipv4_udp_packet_offsets; 7906 return; 7907 } 7908 7909 if (tun_type == ICE_SW_TUN_PPPOE_IPV6) { 7910 *pkt = dummy_pppoe_ipv6_packet; 7911 *pkt_len = sizeof(dummy_pppoe_ipv6_packet); 7912 *offsets = dummy_pppoe_packet_ipv6_offsets; 7913 return; 7914 } 7915 7916 if (tun_type == ICE_SW_TUN_PPPOE_IPV6_TCP) { 7917 *pkt = dummy_pppoe_ipv6_tcp_packet; 7918 *pkt_len = sizeof(dummy_pppoe_ipv6_tcp_packet); 7919 *offsets = dummy_pppoe_packet_ipv6_tcp_offsets; 7920 return; 7921 } 7922 7923 if (tun_type == ICE_SW_TUN_PPPOE_IPV6_UDP) { 7924 *pkt = dummy_pppoe_ipv6_udp_packet; 7925 *pkt_len = sizeof(dummy_pppoe_ipv6_udp_packet); 7926 *offsets = dummy_pppoe_packet_ipv6_udp_offsets; 7927 return; 7928 } 7929 7930 if (tun_type == ICE_SW_IPV4_TCP) { 7931 *pkt = dummy_tcp_packet; 7932 *pkt_len = sizeof(dummy_tcp_packet); 7933 *offsets = dummy_tcp_packet_offsets; 7934 return; 7935 } 7936 7937 if (tun_type == ICE_SW_IPV4_UDP) { 7938 *pkt = dummy_udp_packet; 7939 *pkt_len = sizeof(dummy_udp_packet); 7940 *offsets = dummy_udp_packet_offsets; 7941 return; 7942 } 7943 7944 if (tun_type == ICE_SW_IPV6_TCP) { 7945 *pkt = dummy_tcp_ipv6_packet; 7946 *pkt_len = sizeof(dummy_tcp_ipv6_packet); 7947 *offsets = dummy_tcp_ipv6_packet_offsets; 7948 return; 7949 } 7950 7951 if (tun_type == ICE_SW_IPV6_UDP) { 7952 *pkt = dummy_udp_ipv6_packet; 7953 *pkt_len = sizeof(dummy_udp_ipv6_packet); 7954 *offsets = dummy_udp_ipv6_packet_offsets; 7955 return; 7956 } 7957 7958 /* Support GTP tunnel + L3 */ 7959 if (tun_type == ICE_SW_TUN_IPV4_GTPU_IPV4) { 7960 *pkt = dummy_ipv4_gtpu_ipv4_packet; 7961 *pkt_len = sizeof(dummy_ipv4_gtpu_ipv4_packet); 7962 *offsets = dummy_ipv4_gtpu_ipv4_packet_offsets; 7963 return; 7964 } 7965 if (tun_type == ICE_SW_TUN_IPV4_GTPU_IPV6) { 7966 *pkt = dummy_ipv4_gtpu_ipv6_packet; 7967 *pkt_len = sizeof(dummy_ipv4_gtpu_ipv6_packet); 7968 *offsets = dummy_ipv4_gtpu_ipv6_packet_offsets; 7969 return; 7970 } 7971 if (tun_type == ICE_SW_TUN_IPV6_GTPU_IPV4) { 7972 *pkt = dummy_ipv6_gtpu_ipv4_packet; 7973 *pkt_len = sizeof(dummy_ipv6_gtpu_ipv4_packet); 7974 *offsets = dummy_ipv6_gtpu_ipv4_packet_offsets; 7975 return; 7976 } 7977 if (tun_type == ICE_SW_TUN_IPV6_GTPU_IPV6) { 7978 *pkt = dummy_ipv6_gtpu_ipv6_packet; 7979 *pkt_len = sizeof(dummy_ipv6_gtpu_ipv6_packet); 7980 *offsets = dummy_ipv6_gtpu_ipv6_packet_offsets; 7981 return; 7982 } 7983 7984 if (tun_type == ICE_ALL_TUNNELS) { 7985 *pkt = dummy_gre_udp_packet; 7986 *pkt_len = sizeof(dummy_gre_udp_packet); 7987 *offsets = dummy_gre_udp_packet_offsets; 7988 return; 7989 } 7990 7991 if (tun_type == ICE_SW_TUN_NVGRE || gre) { 7992 if (tcp) { 7993 *pkt = dummy_gre_tcp_packet; 7994 *pkt_len = sizeof(dummy_gre_tcp_packet); 7995 *offsets = dummy_gre_tcp_packet_offsets; 7996 return; 7997 } 7998 7999 *pkt = dummy_gre_udp_packet; 8000 *pkt_len = sizeof(dummy_gre_udp_packet); 8001 *offsets = dummy_gre_udp_packet_offsets; 8002 return; 8003 } 8004 8005 if (tun_type == ICE_SW_TUN_VXLAN || tun_type == ICE_SW_TUN_GENEVE || 8006 tun_type == ICE_SW_TUN_VXLAN_GPE || tun_type == ICE_SW_TUN_UDP || 8007 tun_type == ICE_SW_TUN_GENEVE_VLAN || 8008 tun_type == ICE_SW_TUN_VXLAN_VLAN) { 8009 if (tcp) { 8010 *pkt = dummy_udp_tun_tcp_packet; 8011 *pkt_len = sizeof(dummy_udp_tun_tcp_packet); 8012 *offsets = dummy_udp_tun_tcp_packet_offsets; 8013 return; 8014 } 8015 8016 *pkt = dummy_udp_tun_udp_packet; 8017 *pkt_len = sizeof(dummy_udp_tun_udp_packet); 8018 *offsets = dummy_udp_tun_udp_packet_offsets; 8019 return; 8020 } 8021 8022 if (udp && !ipv6) { 8023 if (vlan) { 8024 *pkt = dummy_vlan_udp_packet; 8025 *pkt_len = sizeof(dummy_vlan_udp_packet); 8026 *offsets = dummy_vlan_udp_packet_offsets; 8027 return; 8028 } 8029 *pkt = dummy_udp_packet; 8030 *pkt_len = sizeof(dummy_udp_packet); 8031 *offsets = dummy_udp_packet_offsets; 8032 return; 8033 } else if (udp && ipv6) { 8034 if (vlan) { 8035 *pkt = dummy_vlan_udp_ipv6_packet; 8036 *pkt_len = sizeof(dummy_vlan_udp_ipv6_packet); 8037 *offsets = dummy_vlan_udp_ipv6_packet_offsets; 8038 return; 8039 } 8040 *pkt = dummy_udp_ipv6_packet; 8041 *pkt_len = sizeof(dummy_udp_ipv6_packet); 8042 *offsets = dummy_udp_ipv6_packet_offsets; 8043 return; 8044 } else if ((tcp && ipv6) || ipv6) { 8045 if (vlan) { 8046 *pkt = dummy_vlan_tcp_ipv6_packet; 8047 *pkt_len = sizeof(dummy_vlan_tcp_ipv6_packet); 8048 *offsets = dummy_vlan_tcp_ipv6_packet_offsets; 8049 return; 8050 } 8051 *pkt = dummy_tcp_ipv6_packet; 8052 *pkt_len = sizeof(dummy_tcp_ipv6_packet); 8053 *offsets = dummy_tcp_ipv6_packet_offsets; 8054 return; 8055 } 8056 8057 if (vlan) { 8058 *pkt = dummy_vlan_tcp_packet; 8059 *pkt_len = sizeof(dummy_vlan_tcp_packet); 8060 *offsets = dummy_vlan_tcp_packet_offsets; 8061 } else { 8062 *pkt = dummy_tcp_packet; 8063 *pkt_len = sizeof(dummy_tcp_packet); 8064 *offsets = dummy_tcp_packet_offsets; 8065 } 8066 } 8067 8068 /** 8069 * ice_fill_adv_dummy_packet - fill a dummy packet with given match criteria 8070 * 8071 * @lkups: lookup elements or match criteria for the advanced recipe, one 8072 * structure per protocol header 8073 * @lkups_cnt: number of protocols 8074 * @s_rule: stores rule information from the match criteria 8075 * @dummy_pkt: dummy packet to fill according to filter match criteria 8076 * @pkt_len: packet length of dummy packet 8077 * @offsets: offset info for the dummy packet 8078 */ 8079 static enum ice_status 8080 ice_fill_adv_dummy_packet(struct ice_adv_lkup_elem *lkups, u16 lkups_cnt, 8081 struct ice_aqc_sw_rules_elem *s_rule, 8082 const u8 *dummy_pkt, u16 pkt_len, 8083 const struct ice_dummy_pkt_offsets *offsets) 8084 { 8085 u8 *pkt; 8086 u16 i; 8087 8088 /* Start with a packet with a pre-defined/dummy content. Then, fill 8089 * in the header values to be looked up or matched. 8090 */ 8091 pkt = s_rule->pdata.lkup_tx_rx.hdr; 8092 8093 ice_memcpy(pkt, dummy_pkt, pkt_len, ICE_NONDMA_TO_NONDMA); 8094 8095 for (i = 0; i < lkups_cnt; i++) { 8096 enum ice_protocol_type type; 8097 u16 offset = 0, len = 0, j; 8098 bool found = false; 8099 8100 /* find the start of this layer; it should be found since this 8101 * was already checked when search for the dummy packet 8102 */ 8103 type = lkups[i].type; 8104 for (j = 0; offsets[j].type != ICE_PROTOCOL_LAST; j++) { 8105 if (type == offsets[j].type) { 8106 offset = offsets[j].offset; 8107 found = true; 8108 break; 8109 } 8110 } 8111 /* this should never happen in a correct calling sequence */ 8112 if (!found) 8113 return ICE_ERR_PARAM; 8114 8115 switch (lkups[i].type) { 8116 case ICE_MAC_OFOS: 8117 case ICE_MAC_IL: 8118 len = sizeof(struct ice_ether_hdr); 8119 break; 8120 case ICE_ETYPE_OL: 8121 len = sizeof(struct ice_ethtype_hdr); 8122 break; 8123 case ICE_VLAN_OFOS: 8124 case ICE_VLAN_EX: 8125 len = sizeof(struct ice_vlan_hdr); 8126 break; 8127 case ICE_IPV4_OFOS: 8128 case ICE_IPV4_IL: 8129 len = sizeof(struct ice_ipv4_hdr); 8130 break; 8131 case ICE_IPV6_OFOS: 8132 case ICE_IPV6_IL: 8133 len = sizeof(struct ice_ipv6_hdr); 8134 break; 8135 case ICE_TCP_IL: 8136 case ICE_UDP_OF: 8137 case ICE_UDP_ILOS: 8138 len = sizeof(struct ice_l4_hdr); 8139 break; 8140 case ICE_SCTP_IL: 8141 len = sizeof(struct ice_sctp_hdr); 8142 break; 8143 case ICE_NVGRE: 8144 len = sizeof(struct ice_nvgre); 8145 break; 8146 case ICE_VXLAN: 8147 case ICE_GENEVE: 8148 case ICE_VXLAN_GPE: 8149 len = sizeof(struct ice_udp_tnl_hdr); 8150 break; 8151 8152 case ICE_GTP: 8153 case ICE_GTP_NO_PAY: 8154 len = sizeof(struct ice_udp_gtp_hdr); 8155 break; 8156 case ICE_PPPOE: 8157 len = sizeof(struct ice_pppoe_hdr); 8158 break; 8159 case ICE_ESP: 8160 len = sizeof(struct ice_esp_hdr); 8161 break; 8162 case ICE_NAT_T: 8163 len = sizeof(struct ice_nat_t_hdr); 8164 break; 8165 case ICE_AH: 8166 len = sizeof(struct ice_ah_hdr); 8167 break; 8168 case ICE_L2TPV3: 8169 len = sizeof(struct ice_l2tpv3_sess_hdr); 8170 break; 8171 default: 8172 return ICE_ERR_PARAM; 8173 } 8174 8175 /* the length should be a word multiple */ 8176 if (len % ICE_BYTES_PER_WORD) 8177 return ICE_ERR_CFG; 8178 8179 /* We have the offset to the header start, the length, the 8180 * caller's header values and mask. Use this information to 8181 * copy the data into the dummy packet appropriately based on 8182 * the mask. Note that we need to only write the bits as 8183 * indicated by the mask to make sure we don't improperly write 8184 * over any significant packet data. 8185 */ 8186 for (j = 0; j < len / sizeof(u16); j++) 8187 if (((u16 *)&lkups[i].m_u)[j]) 8188 ((u16 *)(pkt + offset))[j] = 8189 (((u16 *)(pkt + offset))[j] & 8190 ~((u16 *)&lkups[i].m_u)[j]) | 8191 (((u16 *)&lkups[i].h_u)[j] & 8192 ((u16 *)&lkups[i].m_u)[j]); 8193 } 8194 8195 s_rule->pdata.lkup_tx_rx.hdr_len = CPU_TO_LE16(pkt_len); 8196 8197 return ICE_SUCCESS; 8198 } 8199 8200 /** 8201 * ice_fill_adv_packet_tun - fill dummy packet with udp tunnel port 8202 * @hw: pointer to the hardware structure 8203 * @tun_type: tunnel type 8204 * @pkt: dummy packet to fill in 8205 * @offsets: offset info for the dummy packet 8206 */ 8207 static enum ice_status 8208 ice_fill_adv_packet_tun(struct ice_hw *hw, enum ice_sw_tunnel_type tun_type, 8209 u8 *pkt, const struct ice_dummy_pkt_offsets *offsets) 8210 { 8211 u16 open_port, i; 8212 8213 switch (tun_type) { 8214 case ICE_SW_TUN_AND_NON_TUN: 8215 case ICE_SW_TUN_VXLAN_GPE: 8216 case ICE_SW_TUN_VXLAN: 8217 case ICE_SW_TUN_VXLAN_VLAN: 8218 case ICE_SW_TUN_UDP: 8219 if (!ice_get_open_tunnel_port(hw, TNL_VXLAN, &open_port)) 8220 return ICE_ERR_CFG; 8221 break; 8222 8223 case ICE_SW_TUN_GENEVE: 8224 case ICE_SW_TUN_GENEVE_VLAN: 8225 if (!ice_get_open_tunnel_port(hw, TNL_GENEVE, &open_port)) 8226 return ICE_ERR_CFG; 8227 break; 8228 8229 default: 8230 /* Nothing needs to be done for this tunnel type */ 8231 return ICE_SUCCESS; 8232 } 8233 8234 /* Find the outer UDP protocol header and insert the port number */ 8235 for (i = 0; offsets[i].type != ICE_PROTOCOL_LAST; i++) { 8236 if (offsets[i].type == ICE_UDP_OF) { 8237 struct ice_l4_hdr *hdr; 8238 u16 offset; 8239 8240 offset = offsets[i].offset; 8241 hdr = (struct ice_l4_hdr *)&pkt[offset]; 8242 hdr->dst_port = CPU_TO_BE16(open_port); 8243 8244 return ICE_SUCCESS; 8245 } 8246 } 8247 8248 return ICE_ERR_CFG; 8249 } 8250 8251 /** 8252 * ice_find_adv_rule_entry - Search a rule entry 8253 * @hw: pointer to the hardware structure 8254 * @lkups: lookup elements or match criteria for the advanced recipe, one 8255 * structure per protocol header 8256 * @lkups_cnt: number of protocols 8257 * @recp_id: recipe ID for which we are finding the rule 8258 * @rinfo: other information regarding the rule e.g. priority and action info 8259 * 8260 * Helper function to search for a given advance rule entry 8261 * Returns pointer to entry storing the rule if found 8262 */ 8263 static struct ice_adv_fltr_mgmt_list_entry * 8264 ice_find_adv_rule_entry(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, 8265 u16 lkups_cnt, u16 recp_id, 8266 struct ice_adv_rule_info *rinfo) 8267 { 8268 struct ice_adv_fltr_mgmt_list_entry *list_itr; 8269 struct ice_switch_info *sw = hw->switch_info; 8270 int i; 8271 8272 LIST_FOR_EACH_ENTRY(list_itr, &sw->recp_list[recp_id].filt_rules, 8273 ice_adv_fltr_mgmt_list_entry, list_entry) { 8274 bool lkups_matched = true; 8275 8276 if (lkups_cnt != list_itr->lkups_cnt) 8277 continue; 8278 for (i = 0; i < list_itr->lkups_cnt; i++) 8279 if (memcmp(&list_itr->lkups[i], &lkups[i], 8280 sizeof(*lkups))) { 8281 lkups_matched = false; 8282 break; 8283 } 8284 if (rinfo->sw_act.flag == list_itr->rule_info.sw_act.flag && 8285 rinfo->tun_type == list_itr->rule_info.tun_type && 8286 lkups_matched) 8287 return list_itr; 8288 } 8289 return NULL; 8290 } 8291 8292 /** 8293 * ice_adv_add_update_vsi_list 8294 * @hw: pointer to the hardware structure 8295 * @m_entry: pointer to current adv filter management list entry 8296 * @cur_fltr: filter information from the book keeping entry 8297 * @new_fltr: filter information with the new VSI to be added 8298 * 8299 * Call AQ command to add or update previously created VSI list with new VSI. 8300 * 8301 * Helper function to do book keeping associated with adding filter information 8302 * The algorithm to do the booking keeping is described below : 8303 * When a VSI needs to subscribe to a given advanced filter 8304 * if only one VSI has been added till now 8305 * Allocate a new VSI list and add two VSIs 8306 * to this list using switch rule command 8307 * Update the previously created switch rule with the 8308 * newly created VSI list ID 8309 * if a VSI list was previously created 8310 * Add the new VSI to the previously created VSI list set 8311 * using the update switch rule command 8312 */ 8313 static enum ice_status 8314 ice_adv_add_update_vsi_list(struct ice_hw *hw, 8315 struct ice_adv_fltr_mgmt_list_entry *m_entry, 8316 struct ice_adv_rule_info *cur_fltr, 8317 struct ice_adv_rule_info *new_fltr) 8318 { 8319 enum ice_status status; 8320 u16 vsi_list_id = 0; 8321 8322 if (cur_fltr->sw_act.fltr_act == ICE_FWD_TO_Q || 8323 cur_fltr->sw_act.fltr_act == ICE_FWD_TO_QGRP || 8324 cur_fltr->sw_act.fltr_act == ICE_DROP_PACKET) 8325 return ICE_ERR_NOT_IMPL; 8326 8327 if ((new_fltr->sw_act.fltr_act == ICE_FWD_TO_Q || 8328 new_fltr->sw_act.fltr_act == ICE_FWD_TO_QGRP) && 8329 (cur_fltr->sw_act.fltr_act == ICE_FWD_TO_VSI || 8330 cur_fltr->sw_act.fltr_act == ICE_FWD_TO_VSI_LIST)) 8331 return ICE_ERR_NOT_IMPL; 8332 8333 if (m_entry->vsi_count < 2 && !m_entry->vsi_list_info) { 8334 /* Only one entry existed in the mapping and it was not already 8335 * a part of a VSI list. So, create a VSI list with the old and 8336 * new VSIs. 8337 */ 8338 struct ice_fltr_info tmp_fltr; 8339 u16 vsi_handle_arr[2]; 8340 8341 /* A rule already exists with the new VSI being added */ 8342 if (cur_fltr->sw_act.fwd_id.hw_vsi_id == 8343 new_fltr->sw_act.fwd_id.hw_vsi_id) 8344 return ICE_ERR_ALREADY_EXISTS; 8345 8346 vsi_handle_arr[0] = cur_fltr->sw_act.vsi_handle; 8347 vsi_handle_arr[1] = new_fltr->sw_act.vsi_handle; 8348 status = ice_create_vsi_list_rule(hw, &vsi_handle_arr[0], 2, 8349 &vsi_list_id, 8350 ICE_SW_LKUP_LAST); 8351 if (status) 8352 return status; 8353 8354 ice_memset(&tmp_fltr, 0, sizeof(tmp_fltr), ICE_NONDMA_MEM); 8355 tmp_fltr.flag = m_entry->rule_info.sw_act.flag; 8356 tmp_fltr.fltr_rule_id = cur_fltr->fltr_rule_id; 8357 tmp_fltr.fltr_act = ICE_FWD_TO_VSI_LIST; 8358 tmp_fltr.fwd_id.vsi_list_id = vsi_list_id; 8359 tmp_fltr.lkup_type = ICE_SW_LKUP_LAST; 8360 8361 /* Update the previous switch rule of "forward to VSI" to 8362 * "fwd to VSI list" 8363 */ 8364 status = ice_update_pkt_fwd_rule(hw, &tmp_fltr); 8365 if (status) 8366 return status; 8367 8368 cur_fltr->sw_act.fwd_id.vsi_list_id = vsi_list_id; 8369 cur_fltr->sw_act.fltr_act = ICE_FWD_TO_VSI_LIST; 8370 m_entry->vsi_list_info = 8371 ice_create_vsi_list_map(hw, &vsi_handle_arr[0], 2, 8372 vsi_list_id); 8373 } else { 8374 u16 vsi_handle = new_fltr->sw_act.vsi_handle; 8375 8376 if (!m_entry->vsi_list_info) 8377 return ICE_ERR_CFG; 8378 8379 /* A rule already exists with the new VSI being added */ 8380 if (ice_is_bit_set(m_entry->vsi_list_info->vsi_map, vsi_handle)) 8381 return ICE_SUCCESS; 8382 8383 /* Update the previously created VSI list set with 8384 * the new VSI ID passed in 8385 */ 8386 vsi_list_id = cur_fltr->sw_act.fwd_id.vsi_list_id; 8387 8388 status = ice_update_vsi_list_rule(hw, &vsi_handle, 1, 8389 vsi_list_id, false, 8390 ice_aqc_opc_update_sw_rules, 8391 ICE_SW_LKUP_LAST); 8392 /* update VSI list mapping info with new VSI ID */ 8393 if (!status) 8394 ice_set_bit(vsi_handle, 8395 m_entry->vsi_list_info->vsi_map); 8396 } 8397 if (!status) 8398 m_entry->vsi_count++; 8399 return status; 8400 } 8401 8402 /** 8403 * ice_add_adv_rule - helper function to create an advanced switch rule 8404 * @hw: pointer to the hardware structure 8405 * @lkups: information on the words that needs to be looked up. All words 8406 * together makes one recipe 8407 * @lkups_cnt: num of entries in the lkups array 8408 * @rinfo: other information related to the rule that needs to be programmed 8409 * @added_entry: this will return recipe_id, rule_id and vsi_handle. should be 8410 * ignored is case of error. 8411 * 8412 * This function can program only 1 rule at a time. The lkups is used to 8413 * describe the all the words that forms the "lookup" portion of the recipe. 8414 * These words can span multiple protocols. Callers to this function need to 8415 * pass in a list of protocol headers with lookup information along and mask 8416 * that determines which words are valid from the given protocol header. 8417 * rinfo describes other information related to this rule such as forwarding 8418 * IDs, priority of this rule, etc. 8419 */ 8420 enum ice_status 8421 ice_add_adv_rule(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, 8422 u16 lkups_cnt, struct ice_adv_rule_info *rinfo, 8423 struct ice_rule_query_data *added_entry) 8424 { 8425 struct ice_adv_fltr_mgmt_list_entry *m_entry, *adv_fltr = NULL; 8426 u16 rid = 0, i, pkt_len, rule_buf_sz, vsi_handle; 8427 const struct ice_dummy_pkt_offsets *pkt_offsets; 8428 struct ice_aqc_sw_rules_elem *s_rule = NULL; 8429 struct LIST_HEAD_TYPE *rule_head; 8430 struct ice_switch_info *sw; 8431 enum ice_status status; 8432 const u8 *pkt = NULL; 8433 bool prof_rule; 8434 u16 word_cnt; 8435 u32 act = 0; 8436 u8 q_rgn; 8437 8438 /* Initialize profile to result index bitmap */ 8439 if (!hw->switch_info->prof_res_bm_init) { 8440 hw->switch_info->prof_res_bm_init = 1; 8441 ice_init_prof_result_bm(hw); 8442 } 8443 8444 prof_rule = ice_is_prof_rule(rinfo->tun_type); 8445 if (!prof_rule && !lkups_cnt) 8446 return ICE_ERR_PARAM; 8447 8448 /* get # of words we need to match */ 8449 word_cnt = 0; 8450 for (i = 0; i < lkups_cnt; i++) { 8451 u16 j, *ptr; 8452 8453 ptr = (u16 *)&lkups[i].m_u; 8454 for (j = 0; j < sizeof(lkups->m_u) / sizeof(u16); j++) 8455 if (ptr[j] != 0) 8456 word_cnt++; 8457 } 8458 8459 if (prof_rule) { 8460 if (word_cnt > ICE_MAX_CHAIN_WORDS) 8461 return ICE_ERR_PARAM; 8462 } else { 8463 if (!word_cnt || word_cnt > ICE_MAX_CHAIN_WORDS) 8464 return ICE_ERR_PARAM; 8465 } 8466 8467 /* make sure that we can locate a dummy packet */ 8468 ice_find_dummy_packet(lkups, lkups_cnt, rinfo->tun_type, &pkt, &pkt_len, 8469 &pkt_offsets); 8470 if (!pkt) { 8471 status = ICE_ERR_PARAM; 8472 goto err_ice_add_adv_rule; 8473 } 8474 8475 if (!(rinfo->sw_act.fltr_act == ICE_FWD_TO_VSI || 8476 rinfo->sw_act.fltr_act == ICE_FWD_TO_Q || 8477 rinfo->sw_act.fltr_act == ICE_FWD_TO_QGRP || 8478 rinfo->sw_act.fltr_act == ICE_DROP_PACKET)) 8479 return ICE_ERR_CFG; 8480 8481 vsi_handle = rinfo->sw_act.vsi_handle; 8482 if (!ice_is_vsi_valid(hw, vsi_handle)) 8483 return ICE_ERR_PARAM; 8484 8485 if (rinfo->sw_act.fltr_act == ICE_FWD_TO_VSI) 8486 rinfo->sw_act.fwd_id.hw_vsi_id = 8487 ice_get_hw_vsi_num(hw, vsi_handle); 8488 if (rinfo->sw_act.flag & ICE_FLTR_TX) 8489 rinfo->sw_act.src = ice_get_hw_vsi_num(hw, vsi_handle); 8490 8491 status = ice_add_adv_recipe(hw, lkups, lkups_cnt, rinfo, &rid); 8492 if (status) 8493 return status; 8494 m_entry = ice_find_adv_rule_entry(hw, lkups, lkups_cnt, rid, rinfo); 8495 if (m_entry) { 8496 /* we have to add VSI to VSI_LIST and increment vsi_count. 8497 * Also Update VSI list so that we can change forwarding rule 8498 * if the rule already exists, we will check if it exists with 8499 * same vsi_id, if not then add it to the VSI list if it already 8500 * exists if not then create a VSI list and add the existing VSI 8501 * ID and the new VSI ID to the list 8502 * We will add that VSI to the list 8503 */ 8504 status = ice_adv_add_update_vsi_list(hw, m_entry, 8505 &m_entry->rule_info, 8506 rinfo); 8507 if (added_entry) { 8508 added_entry->rid = rid; 8509 added_entry->rule_id = m_entry->rule_info.fltr_rule_id; 8510 added_entry->vsi_handle = rinfo->sw_act.vsi_handle; 8511 } 8512 return status; 8513 } 8514 rule_buf_sz = ICE_SW_RULE_RX_TX_NO_HDR_SIZE + pkt_len; 8515 s_rule = (struct ice_aqc_sw_rules_elem *)ice_malloc(hw, rule_buf_sz); 8516 if (!s_rule) 8517 return ICE_ERR_NO_MEMORY; 8518 act |= ICE_SINGLE_ACT_LAN_ENABLE; 8519 switch (rinfo->sw_act.fltr_act) { 8520 case ICE_FWD_TO_VSI: 8521 act |= (rinfo->sw_act.fwd_id.hw_vsi_id << 8522 ICE_SINGLE_ACT_VSI_ID_S) & ICE_SINGLE_ACT_VSI_ID_M; 8523 act |= ICE_SINGLE_ACT_VSI_FORWARDING | ICE_SINGLE_ACT_VALID_BIT; 8524 break; 8525 case ICE_FWD_TO_Q: 8526 act |= ICE_SINGLE_ACT_TO_Q; 8527 act |= (rinfo->sw_act.fwd_id.q_id << ICE_SINGLE_ACT_Q_INDEX_S) & 8528 ICE_SINGLE_ACT_Q_INDEX_M; 8529 break; 8530 case ICE_FWD_TO_QGRP: 8531 q_rgn = rinfo->sw_act.qgrp_size > 0 ? 8532 (u8)ice_ilog2(rinfo->sw_act.qgrp_size) : 0; 8533 act |= ICE_SINGLE_ACT_TO_Q; 8534 act |= (rinfo->sw_act.fwd_id.q_id << ICE_SINGLE_ACT_Q_INDEX_S) & 8535 ICE_SINGLE_ACT_Q_INDEX_M; 8536 act |= (q_rgn << ICE_SINGLE_ACT_Q_REGION_S) & 8537 ICE_SINGLE_ACT_Q_REGION_M; 8538 break; 8539 case ICE_DROP_PACKET: 8540 act |= ICE_SINGLE_ACT_VSI_FORWARDING | ICE_SINGLE_ACT_DROP | 8541 ICE_SINGLE_ACT_VALID_BIT; 8542 break; 8543 default: 8544 status = ICE_ERR_CFG; 8545 goto err_ice_add_adv_rule; 8546 } 8547 8548 /* set the rule LOOKUP type based on caller specified 'RX' 8549 * instead of hardcoding it to be either LOOKUP_TX/RX 8550 * 8551 * for 'RX' set the source to be the port number 8552 * for 'TX' set the source to be the source HW VSI number (determined 8553 * by caller) 8554 */ 8555 if (rinfo->rx) { 8556 s_rule->type = CPU_TO_LE16(ICE_AQC_SW_RULES_T_LKUP_RX); 8557 s_rule->pdata.lkup_tx_rx.src = 8558 CPU_TO_LE16(hw->port_info->lport); 8559 } else { 8560 s_rule->type = CPU_TO_LE16(ICE_AQC_SW_RULES_T_LKUP_TX); 8561 s_rule->pdata.lkup_tx_rx.src = CPU_TO_LE16(rinfo->sw_act.src); 8562 } 8563 8564 s_rule->pdata.lkup_tx_rx.recipe_id = CPU_TO_LE16(rid); 8565 s_rule->pdata.lkup_tx_rx.act = CPU_TO_LE32(act); 8566 8567 status = ice_fill_adv_dummy_packet(lkups, lkups_cnt, s_rule, pkt, 8568 pkt_len, pkt_offsets); 8569 if (status) 8570 goto err_ice_add_adv_rule; 8571 8572 if (rinfo->tun_type != ICE_NON_TUN && 8573 rinfo->tun_type != ICE_SW_TUN_AND_NON_TUN) { 8574 status = ice_fill_adv_packet_tun(hw, rinfo->tun_type, 8575 s_rule->pdata.lkup_tx_rx.hdr, 8576 pkt_offsets); 8577 if (status) 8578 goto err_ice_add_adv_rule; 8579 } 8580 8581 status = ice_aq_sw_rules(hw, (struct ice_aqc_sw_rules *)s_rule, 8582 rule_buf_sz, 1, ice_aqc_opc_add_sw_rules, 8583 NULL); 8584 if (status) 8585 goto err_ice_add_adv_rule; 8586 adv_fltr = (struct ice_adv_fltr_mgmt_list_entry *) 8587 ice_malloc(hw, sizeof(struct ice_adv_fltr_mgmt_list_entry)); 8588 if (!adv_fltr) { 8589 status = ICE_ERR_NO_MEMORY; 8590 goto err_ice_add_adv_rule; 8591 } 8592 8593 adv_fltr->lkups = (struct ice_adv_lkup_elem *) 8594 ice_memdup(hw, lkups, lkups_cnt * sizeof(*lkups), 8595 ICE_NONDMA_TO_NONDMA); 8596 if (!adv_fltr->lkups && !prof_rule) { 8597 status = ICE_ERR_NO_MEMORY; 8598 goto err_ice_add_adv_rule; 8599 } 8600 8601 adv_fltr->lkups_cnt = lkups_cnt; 8602 adv_fltr->rule_info = *rinfo; 8603 adv_fltr->rule_info.fltr_rule_id = 8604 LE16_TO_CPU(s_rule->pdata.lkup_tx_rx.index); 8605 sw = hw->switch_info; 8606 sw->recp_list[rid].adv_rule = true; 8607 rule_head = &sw->recp_list[rid].filt_rules; 8608 8609 if (rinfo->sw_act.fltr_act == ICE_FWD_TO_VSI) 8610 adv_fltr->vsi_count = 1; 8611 8612 /* Add rule entry to book keeping list */ 8613 LIST_ADD(&adv_fltr->list_entry, rule_head); 8614 if (added_entry) { 8615 added_entry->rid = rid; 8616 added_entry->rule_id = adv_fltr->rule_info.fltr_rule_id; 8617 added_entry->vsi_handle = rinfo->sw_act.vsi_handle; 8618 } 8619 err_ice_add_adv_rule: 8620 if (status && adv_fltr) { 8621 ice_free(hw, adv_fltr->lkups); 8622 ice_free(hw, adv_fltr); 8623 } 8624 8625 ice_free(hw, s_rule); 8626 8627 return status; 8628 } 8629 8630 /** 8631 * ice_adv_rem_update_vsi_list 8632 * @hw: pointer to the hardware structure 8633 * @vsi_handle: VSI handle of the VSI to remove 8634 * @fm_list: filter management entry for which the VSI list management needs to 8635 * be done 8636 */ 8637 static enum ice_status 8638 ice_adv_rem_update_vsi_list(struct ice_hw *hw, u16 vsi_handle, 8639 struct ice_adv_fltr_mgmt_list_entry *fm_list) 8640 { 8641 struct ice_vsi_list_map_info *vsi_list_info; 8642 enum ice_sw_lkup_type lkup_type; 8643 enum ice_status status; 8644 u16 vsi_list_id; 8645 8646 if (fm_list->rule_info.sw_act.fltr_act != ICE_FWD_TO_VSI_LIST || 8647 fm_list->vsi_count == 0) 8648 return ICE_ERR_PARAM; 8649 8650 /* A rule with the VSI being removed does not exist */ 8651 if (!ice_is_bit_set(fm_list->vsi_list_info->vsi_map, vsi_handle)) 8652 return ICE_ERR_DOES_NOT_EXIST; 8653 8654 lkup_type = ICE_SW_LKUP_LAST; 8655 vsi_list_id = fm_list->rule_info.sw_act.fwd_id.vsi_list_id; 8656 status = ice_update_vsi_list_rule(hw, &vsi_handle, 1, vsi_list_id, true, 8657 ice_aqc_opc_update_sw_rules, 8658 lkup_type); 8659 if (status) 8660 return status; 8661 8662 fm_list->vsi_count--; 8663 ice_clear_bit(vsi_handle, fm_list->vsi_list_info->vsi_map); 8664 vsi_list_info = fm_list->vsi_list_info; 8665 if (fm_list->vsi_count == 1) { 8666 struct ice_fltr_info tmp_fltr; 8667 u16 rem_vsi_handle; 8668 8669 rem_vsi_handle = ice_find_first_bit(vsi_list_info->vsi_map, 8670 ICE_MAX_VSI); 8671 if (!ice_is_vsi_valid(hw, rem_vsi_handle)) 8672 return ICE_ERR_OUT_OF_RANGE; 8673 8674 /* Make sure VSI list is empty before removing it below */ 8675 status = ice_update_vsi_list_rule(hw, &rem_vsi_handle, 1, 8676 vsi_list_id, true, 8677 ice_aqc_opc_update_sw_rules, 8678 lkup_type); 8679 if (status) 8680 return status; 8681 8682 ice_memset(&tmp_fltr, 0, sizeof(tmp_fltr), ICE_NONDMA_MEM); 8683 tmp_fltr.flag = fm_list->rule_info.sw_act.flag; 8684 tmp_fltr.fltr_rule_id = fm_list->rule_info.fltr_rule_id; 8685 fm_list->rule_info.sw_act.fltr_act = ICE_FWD_TO_VSI; 8686 tmp_fltr.fltr_act = ICE_FWD_TO_VSI; 8687 tmp_fltr.fwd_id.hw_vsi_id = 8688 ice_get_hw_vsi_num(hw, rem_vsi_handle); 8689 fm_list->rule_info.sw_act.fwd_id.hw_vsi_id = 8690 ice_get_hw_vsi_num(hw, rem_vsi_handle); 8691 fm_list->rule_info.sw_act.vsi_handle = rem_vsi_handle; 8692 8693 /* Update the previous switch rule of "MAC forward to VSI" to 8694 * "MAC fwd to VSI list" 8695 */ 8696 status = ice_update_pkt_fwd_rule(hw, &tmp_fltr); 8697 if (status) { 8698 ice_debug(hw, ICE_DBG_SW, "Failed to update pkt fwd rule to FWD_TO_VSI on HW VSI %d, error %d\n", 8699 tmp_fltr.fwd_id.hw_vsi_id, status); 8700 return status; 8701 } 8702 fm_list->vsi_list_info->ref_cnt--; 8703 8704 /* Remove the VSI list since it is no longer used */ 8705 status = ice_remove_vsi_list_rule(hw, vsi_list_id, lkup_type); 8706 if (status) { 8707 ice_debug(hw, ICE_DBG_SW, "Failed to remove VSI list %d, error %d\n", 8708 vsi_list_id, status); 8709 return status; 8710 } 8711 8712 LIST_DEL(&vsi_list_info->list_entry); 8713 ice_free(hw, vsi_list_info); 8714 fm_list->vsi_list_info = NULL; 8715 } 8716 8717 return status; 8718 } 8719 8720 /** 8721 * ice_rem_adv_rule - removes existing advanced switch rule 8722 * @hw: pointer to the hardware structure 8723 * @lkups: information on the words that needs to be looked up. All words 8724 * together makes one recipe 8725 * @lkups_cnt: num of entries in the lkups array 8726 * @rinfo: Its the pointer to the rule information for the rule 8727 * 8728 * This function can be used to remove 1 rule at a time. The lkups is 8729 * used to describe all the words that forms the "lookup" portion of the 8730 * rule. These words can span multiple protocols. Callers to this function 8731 * need to pass in a list of protocol headers with lookup information along 8732 * and mask that determines which words are valid from the given protocol 8733 * header. rinfo describes other information related to this rule such as 8734 * forwarding IDs, priority of this rule, etc. 8735 */ 8736 enum ice_status 8737 ice_rem_adv_rule(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, 8738 u16 lkups_cnt, struct ice_adv_rule_info *rinfo) 8739 { 8740 struct ice_adv_fltr_mgmt_list_entry *list_elem; 8741 struct ice_prot_lkup_ext lkup_exts; 8742 struct ice_lock *rule_lock; /* Lock to protect filter rule list */ 8743 enum ice_status status = ICE_SUCCESS; 8744 bool remove_rule = false; 8745 u16 i, rid, vsi_handle; 8746 8747 ice_memset(&lkup_exts, 0, sizeof(lkup_exts), ICE_NONDMA_MEM); 8748 for (i = 0; i < lkups_cnt; i++) { 8749 u16 count; 8750 8751 if (lkups[i].type >= ICE_PROTOCOL_LAST) 8752 return ICE_ERR_CFG; 8753 8754 count = ice_fill_valid_words(&lkups[i], &lkup_exts); 8755 if (!count) 8756 return ICE_ERR_CFG; 8757 } 8758 8759 /* Create any special protocol/offset pairs, such as looking at tunnel 8760 * bits by extracting metadata 8761 */ 8762 status = ice_add_special_words(rinfo, &lkup_exts); 8763 if (status) 8764 return status; 8765 8766 rid = ice_find_recp(hw, &lkup_exts, rinfo->tun_type); 8767 /* If did not find a recipe that match the existing criteria */ 8768 if (rid == ICE_MAX_NUM_RECIPES) 8769 return ICE_ERR_PARAM; 8770 8771 rule_lock = &hw->switch_info->recp_list[rid].filt_rule_lock; 8772 list_elem = ice_find_adv_rule_entry(hw, lkups, lkups_cnt, rid, rinfo); 8773 /* the rule is already removed */ 8774 if (!list_elem) 8775 return ICE_SUCCESS; 8776 ice_acquire_lock(rule_lock); 8777 if (list_elem->rule_info.sw_act.fltr_act != ICE_FWD_TO_VSI_LIST) { 8778 remove_rule = true; 8779 } else if (list_elem->vsi_count > 1) { 8780 remove_rule = false; 8781 vsi_handle = rinfo->sw_act.vsi_handle; 8782 status = ice_adv_rem_update_vsi_list(hw, vsi_handle, list_elem); 8783 } else { 8784 vsi_handle = rinfo->sw_act.vsi_handle; 8785 status = ice_adv_rem_update_vsi_list(hw, vsi_handle, list_elem); 8786 if (status) { 8787 ice_release_lock(rule_lock); 8788 return status; 8789 } 8790 if (list_elem->vsi_count == 0) 8791 remove_rule = true; 8792 } 8793 ice_release_lock(rule_lock); 8794 if (remove_rule) { 8795 struct ice_aqc_sw_rules_elem *s_rule; 8796 u16 rule_buf_sz; 8797 8798 rule_buf_sz = ICE_SW_RULE_RX_TX_NO_HDR_SIZE; 8799 s_rule = (struct ice_aqc_sw_rules_elem *) 8800 ice_malloc(hw, rule_buf_sz); 8801 if (!s_rule) 8802 return ICE_ERR_NO_MEMORY; 8803 s_rule->pdata.lkup_tx_rx.act = 0; 8804 s_rule->pdata.lkup_tx_rx.index = 8805 CPU_TO_LE16(list_elem->rule_info.fltr_rule_id); 8806 s_rule->pdata.lkup_tx_rx.hdr_len = 0; 8807 status = ice_aq_sw_rules(hw, (struct ice_aqc_sw_rules *)s_rule, 8808 rule_buf_sz, 1, 8809 ice_aqc_opc_remove_sw_rules, NULL); 8810 if (status == ICE_SUCCESS || status == ICE_ERR_DOES_NOT_EXIST) { 8811 struct ice_switch_info *sw = hw->switch_info; 8812 8813 ice_acquire_lock(rule_lock); 8814 LIST_DEL(&list_elem->list_entry); 8815 ice_free(hw, list_elem->lkups); 8816 ice_free(hw, list_elem); 8817 ice_release_lock(rule_lock); 8818 if (LIST_EMPTY(&sw->recp_list[rid].filt_rules)) 8819 sw->recp_list[rid].adv_rule = false; 8820 } 8821 ice_free(hw, s_rule); 8822 } 8823 return status; 8824 } 8825 8826 /** 8827 * ice_rem_adv_rule_by_id - removes existing advanced switch rule by ID 8828 * @hw: pointer to the hardware structure 8829 * @remove_entry: data struct which holds rule_id, VSI handle and recipe ID 8830 * 8831 * This function is used to remove 1 rule at a time. The removal is based on 8832 * the remove_entry parameter. This function will remove rule for a given 8833 * vsi_handle with a given rule_id which is passed as parameter in remove_entry 8834 */ 8835 enum ice_status 8836 ice_rem_adv_rule_by_id(struct ice_hw *hw, 8837 struct ice_rule_query_data *remove_entry) 8838 { 8839 struct ice_adv_fltr_mgmt_list_entry *list_itr; 8840 struct LIST_HEAD_TYPE *list_head; 8841 struct ice_adv_rule_info rinfo; 8842 struct ice_switch_info *sw; 8843 8844 sw = hw->switch_info; 8845 if (!sw->recp_list[remove_entry->rid].recp_created) 8846 return ICE_ERR_PARAM; 8847 list_head = &sw->recp_list[remove_entry->rid].filt_rules; 8848 LIST_FOR_EACH_ENTRY(list_itr, list_head, ice_adv_fltr_mgmt_list_entry, 8849 list_entry) { 8850 if (list_itr->rule_info.fltr_rule_id == 8851 remove_entry->rule_id) { 8852 rinfo = list_itr->rule_info; 8853 rinfo.sw_act.vsi_handle = remove_entry->vsi_handle; 8854 return ice_rem_adv_rule(hw, list_itr->lkups, 8855 list_itr->lkups_cnt, &rinfo); 8856 } 8857 } 8858 /* either list is empty or unable to find rule */ 8859 return ICE_ERR_DOES_NOT_EXIST; 8860 } 8861 8862 /** 8863 * ice_rem_adv_for_vsi - removes existing advanced switch rules for a 8864 * given VSI handle 8865 * @hw: pointer to the hardware structure 8866 * @vsi_handle: VSI handle for which we are supposed to remove all the rules. 8867 * 8868 * This function is used to remove all the rules for a given VSI and as soon 8869 * as removing a rule fails, it will return immediately with the error code, 8870 * else it will return ICE_SUCCESS 8871 */ 8872 enum ice_status ice_rem_adv_rule_for_vsi(struct ice_hw *hw, u16 vsi_handle) 8873 { 8874 struct ice_adv_fltr_mgmt_list_entry *list_itr, *tmp_entry; 8875 struct ice_vsi_list_map_info *map_info; 8876 struct LIST_HEAD_TYPE *list_head; 8877 struct ice_adv_rule_info rinfo; 8878 struct ice_switch_info *sw; 8879 enum ice_status status; 8880 u8 rid; 8881 8882 sw = hw->switch_info; 8883 for (rid = 0; rid < ICE_MAX_NUM_RECIPES; rid++) { 8884 if (!sw->recp_list[rid].recp_created) 8885 continue; 8886 if (!sw->recp_list[rid].adv_rule) 8887 continue; 8888 8889 list_head = &sw->recp_list[rid].filt_rules; 8890 LIST_FOR_EACH_ENTRY_SAFE(list_itr, tmp_entry, list_head, 8891 ice_adv_fltr_mgmt_list_entry, 8892 list_entry) { 8893 rinfo = list_itr->rule_info; 8894 8895 if (rinfo.sw_act.fltr_act == ICE_FWD_TO_VSI_LIST) { 8896 map_info = list_itr->vsi_list_info; 8897 if (!map_info) 8898 continue; 8899 8900 if (!ice_is_bit_set(map_info->vsi_map, 8901 vsi_handle)) 8902 continue; 8903 } else if (rinfo.sw_act.vsi_handle != vsi_handle) { 8904 continue; 8905 } 8906 8907 rinfo.sw_act.vsi_handle = vsi_handle; 8908 status = ice_rem_adv_rule(hw, list_itr->lkups, 8909 list_itr->lkups_cnt, &rinfo); 8910 8911 if (status) 8912 return status; 8913 } 8914 } 8915 return ICE_SUCCESS; 8916 } 8917 8918 /** 8919 * ice_replay_fltr - Replay all the filters stored by a specific list head 8920 * @hw: pointer to the hardware structure 8921 * @list_head: list for which filters needs to be replayed 8922 * @recp_id: Recipe ID for which rules need to be replayed 8923 */ 8924 static enum ice_status 8925 ice_replay_fltr(struct ice_hw *hw, u8 recp_id, struct LIST_HEAD_TYPE *list_head) 8926 { 8927 struct ice_fltr_mgmt_list_entry *itr; 8928 enum ice_status status = ICE_SUCCESS; 8929 struct ice_sw_recipe *recp_list; 8930 u8 lport = hw->port_info->lport; 8931 struct LIST_HEAD_TYPE l_head; 8932 8933 if (LIST_EMPTY(list_head)) 8934 return status; 8935 8936 recp_list = &hw->switch_info->recp_list[recp_id]; 8937 /* Move entries from the given list_head to a temporary l_head so that 8938 * they can be replayed. Otherwise when trying to re-add the same 8939 * filter, the function will return already exists 8940 */ 8941 LIST_REPLACE_INIT(list_head, &l_head); 8942 8943 /* Mark the given list_head empty by reinitializing it so filters 8944 * could be added again by *handler 8945 */ 8946 LIST_FOR_EACH_ENTRY(itr, &l_head, ice_fltr_mgmt_list_entry, 8947 list_entry) { 8948 struct ice_fltr_list_entry f_entry; 8949 u16 vsi_handle; 8950 8951 f_entry.fltr_info = itr->fltr_info; 8952 if (itr->vsi_count < 2 && recp_id != ICE_SW_LKUP_VLAN) { 8953 status = ice_add_rule_internal(hw, recp_list, lport, 8954 &f_entry); 8955 if (status != ICE_SUCCESS) 8956 goto end; 8957 continue; 8958 } 8959 8960 /* Add a filter per VSI separately */ 8961 ice_for_each_set_bit(vsi_handle, itr->vsi_list_info->vsi_map, 8962 ICE_MAX_VSI) { 8963 if (!ice_is_vsi_valid(hw, vsi_handle)) 8964 break; 8965 8966 ice_clear_bit(vsi_handle, itr->vsi_list_info->vsi_map); 8967 f_entry.fltr_info.vsi_handle = vsi_handle; 8968 f_entry.fltr_info.fwd_id.hw_vsi_id = 8969 ice_get_hw_vsi_num(hw, vsi_handle); 8970 f_entry.fltr_info.fltr_act = ICE_FWD_TO_VSI; 8971 if (recp_id == ICE_SW_LKUP_VLAN) 8972 status = ice_add_vlan_internal(hw, recp_list, 8973 &f_entry); 8974 else 8975 status = ice_add_rule_internal(hw, recp_list, 8976 lport, 8977 &f_entry); 8978 if (status != ICE_SUCCESS) 8979 goto end; 8980 } 8981 } 8982 end: 8983 /* Clear the filter management list */ 8984 ice_rem_sw_rule_info(hw, &l_head); 8985 return status; 8986 } 8987 8988 /** 8989 * ice_replay_all_fltr - replay all filters stored in bookkeeping lists 8990 * @hw: pointer to the hardware structure 8991 * 8992 * NOTE: This function does not clean up partially added filters on error. 8993 * It is up to caller of the function to issue a reset or fail early. 8994 */ 8995 enum ice_status ice_replay_all_fltr(struct ice_hw *hw) 8996 { 8997 struct ice_switch_info *sw = hw->switch_info; 8998 enum ice_status status = ICE_SUCCESS; 8999 u8 i; 9000 9001 for (i = 0; i < ICE_MAX_NUM_RECIPES; i++) { 9002 struct LIST_HEAD_TYPE *head = &sw->recp_list[i].filt_rules; 9003 9004 status = ice_replay_fltr(hw, i, head); 9005 if (status != ICE_SUCCESS) 9006 return status; 9007 } 9008 return status; 9009 } 9010 9011 /** 9012 * ice_replay_vsi_fltr - Replay filters for requested VSI 9013 * @hw: pointer to the hardware structure 9014 * @pi: pointer to port information structure 9015 * @sw: pointer to switch info struct for which function replays filters 9016 * @vsi_handle: driver VSI handle 9017 * @recp_id: Recipe ID for which rules need to be replayed 9018 * @list_head: list for which filters need to be replayed 9019 * 9020 * Replays the filter of recipe recp_id for a VSI represented via vsi_handle. 9021 * It is required to pass valid VSI handle. 9022 */ 9023 static enum ice_status 9024 ice_replay_vsi_fltr(struct ice_hw *hw, struct ice_port_info *pi, 9025 struct ice_switch_info *sw, u16 vsi_handle, u8 recp_id, 9026 struct LIST_HEAD_TYPE *list_head) 9027 { 9028 struct ice_fltr_mgmt_list_entry *itr; 9029 enum ice_status status = ICE_SUCCESS; 9030 struct ice_sw_recipe *recp_list; 9031 u16 hw_vsi_id; 9032 9033 if (LIST_EMPTY(list_head)) 9034 return status; 9035 recp_list = &sw->recp_list[recp_id]; 9036 hw_vsi_id = ice_get_hw_vsi_num(hw, vsi_handle); 9037 9038 LIST_FOR_EACH_ENTRY(itr, list_head, ice_fltr_mgmt_list_entry, 9039 list_entry) { 9040 struct ice_fltr_list_entry f_entry; 9041 9042 f_entry.fltr_info = itr->fltr_info; 9043 if (itr->vsi_count < 2 && recp_id != ICE_SW_LKUP_VLAN && 9044 itr->fltr_info.vsi_handle == vsi_handle) { 9045 /* update the src in case it is VSI num */ 9046 if (f_entry.fltr_info.src_id == ICE_SRC_ID_VSI) 9047 f_entry.fltr_info.src = hw_vsi_id; 9048 status = ice_add_rule_internal(hw, recp_list, 9049 pi->lport, 9050 &f_entry); 9051 if (status != ICE_SUCCESS) 9052 goto end; 9053 continue; 9054 } 9055 if (!itr->vsi_list_info || 9056 !ice_is_bit_set(itr->vsi_list_info->vsi_map, vsi_handle)) 9057 continue; 9058 /* Clearing it so that the logic can add it back */ 9059 ice_clear_bit(vsi_handle, itr->vsi_list_info->vsi_map); 9060 f_entry.fltr_info.vsi_handle = vsi_handle; 9061 f_entry.fltr_info.fltr_act = ICE_FWD_TO_VSI; 9062 /* update the src in case it is VSI num */ 9063 if (f_entry.fltr_info.src_id == ICE_SRC_ID_VSI) 9064 f_entry.fltr_info.src = hw_vsi_id; 9065 if (recp_id == ICE_SW_LKUP_VLAN) 9066 status = ice_add_vlan_internal(hw, recp_list, &f_entry); 9067 else 9068 status = ice_add_rule_internal(hw, recp_list, 9069 pi->lport, 9070 &f_entry); 9071 if (status != ICE_SUCCESS) 9072 goto end; 9073 } 9074 end: 9075 return status; 9076 } 9077 9078 /** 9079 * ice_replay_vsi_adv_rule - Replay advanced rule for requested VSI 9080 * @hw: pointer to the hardware structure 9081 * @vsi_handle: driver VSI handle 9082 * @list_head: list for which filters need to be replayed 9083 * 9084 * Replay the advanced rule for the given VSI. 9085 */ 9086 static enum ice_status 9087 ice_replay_vsi_adv_rule(struct ice_hw *hw, u16 vsi_handle, 9088 struct LIST_HEAD_TYPE *list_head) 9089 { 9090 struct ice_rule_query_data added_entry = { 0 }; 9091 struct ice_adv_fltr_mgmt_list_entry *adv_fltr; 9092 enum ice_status status = ICE_SUCCESS; 9093 9094 if (LIST_EMPTY(list_head)) 9095 return status; 9096 LIST_FOR_EACH_ENTRY(adv_fltr, list_head, ice_adv_fltr_mgmt_list_entry, 9097 list_entry) { 9098 struct ice_adv_rule_info *rinfo = &adv_fltr->rule_info; 9099 u16 lk_cnt = adv_fltr->lkups_cnt; 9100 9101 if (vsi_handle != rinfo->sw_act.vsi_handle) 9102 continue; 9103 status = ice_add_adv_rule(hw, adv_fltr->lkups, lk_cnt, rinfo, 9104 &added_entry); 9105 if (status) 9106 break; 9107 } 9108 return status; 9109 } 9110 9111 /** 9112 * ice_replay_vsi_all_fltr - replay all filters stored in bookkeeping lists 9113 * @hw: pointer to the hardware structure 9114 * @pi: pointer to port information structure 9115 * @vsi_handle: driver VSI handle 9116 * 9117 * Replays filters for requested VSI via vsi_handle. 9118 */ 9119 enum ice_status 9120 ice_replay_vsi_all_fltr(struct ice_hw *hw, struct ice_port_info *pi, 9121 u16 vsi_handle) 9122 { 9123 struct ice_switch_info *sw = hw->switch_info; 9124 enum ice_status status; 9125 u8 i; 9126 9127 /* Update the recipes that were created */ 9128 for (i = 0; i < ICE_MAX_NUM_RECIPES; i++) { 9129 struct LIST_HEAD_TYPE *head; 9130 9131 head = &sw->recp_list[i].filt_replay_rules; 9132 if (!sw->recp_list[i].adv_rule) 9133 status = ice_replay_vsi_fltr(hw, pi, sw, vsi_handle, i, 9134 head); 9135 else 9136 status = ice_replay_vsi_adv_rule(hw, vsi_handle, head); 9137 if (status != ICE_SUCCESS) 9138 return status; 9139 } 9140 9141 return ICE_SUCCESS; 9142 } 9143 9144 /** 9145 * ice_rm_all_sw_replay_rule - helper function to delete filter replay rules 9146 * @hw: pointer to the HW struct 9147 * @sw: pointer to switch info struct for which function removes filters 9148 * 9149 * Deletes the filter replay rules for given switch 9150 */ 9151 void ice_rm_sw_replay_rule_info(struct ice_hw *hw, struct ice_switch_info *sw) 9152 { 9153 u8 i; 9154 9155 if (!sw) 9156 return; 9157 9158 for (i = 0; i < ICE_MAX_NUM_RECIPES; i++) { 9159 if (!LIST_EMPTY(&sw->recp_list[i].filt_replay_rules)) { 9160 struct LIST_HEAD_TYPE *l_head; 9161 9162 l_head = &sw->recp_list[i].filt_replay_rules; 9163 if (!sw->recp_list[i].adv_rule) 9164 ice_rem_sw_rule_info(hw, l_head); 9165 else 9166 ice_rem_adv_rule_info(hw, l_head); 9167 } 9168 } 9169 } 9170 9171 /** 9172 * ice_rm_all_sw_replay_rule_info - deletes filter replay rules 9173 * @hw: pointer to the HW struct 9174 * 9175 * Deletes the filter replay rules. 9176 */ 9177 void ice_rm_all_sw_replay_rule_info(struct ice_hw *hw) 9178 { 9179 ice_rm_sw_replay_rule_info(hw, hw->switch_info); 9180 } 9181