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