1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (c) 2018, Intel Corporation. */ 3 4 #include "ice_lib.h" 5 #include "ice_switch.h" 6 #include "ice_trace.h" 7 8 #define ICE_ETH_DA_OFFSET 0 9 #define ICE_ETH_ETHTYPE_OFFSET 12 10 #define ICE_ETH_VLAN_TCI_OFFSET 14 11 #define ICE_MAX_VLAN_ID 0xFFF 12 #define ICE_IPV6_ETHER_ID 0x86DD 13 14 /* Dummy ethernet header needed in the ice_aqc_sw_rules_elem 15 * struct to configure any switch filter rules. 16 * {DA (6 bytes), SA(6 bytes), 17 * Ether type (2 bytes for header without VLAN tag) OR 18 * VLAN tag (4 bytes for header with VLAN tag) } 19 * 20 * Word on Hardcoded values 21 * byte 0 = 0x2: to identify it as locally administered DA MAC 22 * byte 6 = 0x2: to identify it as locally administered SA MAC 23 * byte 12 = 0x81 & byte 13 = 0x00: 24 * In case of VLAN filter first two bytes defines ether type (0x8100) 25 * and remaining two bytes are placeholder for programming a given VLAN ID 26 * In case of Ether type filter it is treated as header without VLAN tag 27 * and byte 12 and 13 is used to program a given Ether type instead 28 */ 29 static const u8 dummy_eth_header[DUMMY_ETH_HDR_LEN] = { 0x2, 0, 0, 0, 0, 0, 30 0x2, 0, 0, 0, 0, 0, 31 0x81, 0, 0, 0}; 32 33 enum { 34 ICE_PKT_OUTER_IPV6 = BIT(0), 35 ICE_PKT_TUN_GTPC = BIT(1), 36 ICE_PKT_TUN_GTPU = BIT(2), 37 ICE_PKT_TUN_NVGRE = BIT(3), 38 ICE_PKT_TUN_UDP = BIT(4), 39 ICE_PKT_INNER_IPV6 = BIT(5), 40 ICE_PKT_INNER_TCP = BIT(6), 41 ICE_PKT_INNER_UDP = BIT(7), 42 ICE_PKT_GTP_NOPAY = BIT(8), 43 ICE_PKT_KMALLOC = BIT(9), 44 ICE_PKT_PPPOE = BIT(10), 45 ICE_PKT_L2TPV3 = BIT(11), 46 ICE_PKT_PFCP = BIT(12), 47 }; 48 49 struct ice_dummy_pkt_offsets { 50 enum ice_protocol_type type; 51 u16 offset; /* ICE_PROTOCOL_LAST indicates end of list */ 52 }; 53 54 struct ice_dummy_pkt_profile { 55 const struct ice_dummy_pkt_offsets *offsets; 56 const u8 *pkt; 57 u32 match; 58 u16 pkt_len; 59 u16 offsets_len; 60 }; 61 62 #define ICE_DECLARE_PKT_OFFSETS(type) \ 63 static const struct ice_dummy_pkt_offsets \ 64 ice_dummy_##type##_packet_offsets[] 65 66 #define ICE_DECLARE_PKT_TEMPLATE(type) \ 67 static const u8 ice_dummy_##type##_packet[] 68 69 #define ICE_PKT_PROFILE(type, m) { \ 70 .match = (m), \ 71 .pkt = ice_dummy_##type##_packet, \ 72 .pkt_len = sizeof(ice_dummy_##type##_packet), \ 73 .offsets = ice_dummy_##type##_packet_offsets, \ 74 .offsets_len = sizeof(ice_dummy_##type##_packet_offsets), \ 75 } 76 77 ICE_DECLARE_PKT_OFFSETS(vlan) = { 78 { ICE_VLAN_OFOS, 12 }, 79 }; 80 81 ICE_DECLARE_PKT_TEMPLATE(vlan) = { 82 0x81, 0x00, 0x00, 0x00, /* ICE_VLAN_OFOS 12 */ 83 }; 84 85 ICE_DECLARE_PKT_OFFSETS(qinq) = { 86 { ICE_VLAN_EX, 12 }, 87 { ICE_VLAN_IN, 16 }, 88 }; 89 90 ICE_DECLARE_PKT_TEMPLATE(qinq) = { 91 0x91, 0x00, 0x00, 0x00, /* ICE_VLAN_EX 12 */ 92 0x81, 0x00, 0x00, 0x00, /* ICE_VLAN_IN 16 */ 93 }; 94 95 ICE_DECLARE_PKT_OFFSETS(gre_tcp) = { 96 { ICE_MAC_OFOS, 0 }, 97 { ICE_ETYPE_OL, 12 }, 98 { ICE_IPV4_OFOS, 14 }, 99 { ICE_NVGRE, 34 }, 100 { ICE_MAC_IL, 42 }, 101 { ICE_ETYPE_IL, 54 }, 102 { ICE_IPV4_IL, 56 }, 103 { ICE_TCP_IL, 76 }, 104 { ICE_PROTOCOL_LAST, 0 }, 105 }; 106 107 ICE_DECLARE_PKT_TEMPLATE(gre_tcp) = { 108 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 109 0x00, 0x00, 0x00, 0x00, 110 0x00, 0x00, 0x00, 0x00, 111 112 0x08, 0x00, /* ICE_ETYPE_OL 12 */ 113 114 0x45, 0x00, 0x00, 0x3E, /* ICE_IPV4_OFOS 14 */ 115 0x00, 0x00, 0x00, 0x00, 116 0x00, 0x2F, 0x00, 0x00, 117 0x00, 0x00, 0x00, 0x00, 118 0x00, 0x00, 0x00, 0x00, 119 120 0x80, 0x00, 0x65, 0x58, /* ICE_NVGRE 34 */ 121 0x00, 0x00, 0x00, 0x00, 122 123 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_IL 42 */ 124 0x00, 0x00, 0x00, 0x00, 125 0x00, 0x00, 0x00, 0x00, 126 127 0x08, 0x00, /* ICE_ETYPE_IL 54 */ 128 129 0x45, 0x00, 0x00, 0x14, /* ICE_IPV4_IL 56 */ 130 0x00, 0x00, 0x00, 0x00, 131 0x00, 0x06, 0x00, 0x00, 132 0x00, 0x00, 0x00, 0x00, 133 0x00, 0x00, 0x00, 0x00, 134 135 0x00, 0x00, 0x00, 0x00, /* ICE_TCP_IL 76 */ 136 0x00, 0x00, 0x00, 0x00, 137 0x00, 0x00, 0x00, 0x00, 138 0x50, 0x02, 0x20, 0x00, 139 0x00, 0x00, 0x00, 0x00 140 }; 141 142 ICE_DECLARE_PKT_OFFSETS(gre_udp) = { 143 { ICE_MAC_OFOS, 0 }, 144 { ICE_ETYPE_OL, 12 }, 145 { ICE_IPV4_OFOS, 14 }, 146 { ICE_NVGRE, 34 }, 147 { ICE_MAC_IL, 42 }, 148 { ICE_ETYPE_IL, 54 }, 149 { ICE_IPV4_IL, 56 }, 150 { ICE_UDP_ILOS, 76 }, 151 { ICE_PROTOCOL_LAST, 0 }, 152 }; 153 154 ICE_DECLARE_PKT_TEMPLATE(gre_udp) = { 155 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 156 0x00, 0x00, 0x00, 0x00, 157 0x00, 0x00, 0x00, 0x00, 158 159 0x08, 0x00, /* ICE_ETYPE_OL 12 */ 160 161 0x45, 0x00, 0x00, 0x3E, /* ICE_IPV4_OFOS 14 */ 162 0x00, 0x00, 0x00, 0x00, 163 0x00, 0x2F, 0x00, 0x00, 164 0x00, 0x00, 0x00, 0x00, 165 0x00, 0x00, 0x00, 0x00, 166 167 0x80, 0x00, 0x65, 0x58, /* ICE_NVGRE 34 */ 168 0x00, 0x00, 0x00, 0x00, 169 170 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_IL 42 */ 171 0x00, 0x00, 0x00, 0x00, 172 0x00, 0x00, 0x00, 0x00, 173 174 0x08, 0x00, /* ICE_ETYPE_IL 54 */ 175 176 0x45, 0x00, 0x00, 0x14, /* ICE_IPV4_IL 56 */ 177 0x00, 0x00, 0x00, 0x00, 178 0x00, 0x11, 0x00, 0x00, 179 0x00, 0x00, 0x00, 0x00, 180 0x00, 0x00, 0x00, 0x00, 181 182 0x00, 0x00, 0x00, 0x00, /* ICE_UDP_ILOS 76 */ 183 0x00, 0x08, 0x00, 0x00, 184 }; 185 186 ICE_DECLARE_PKT_OFFSETS(udp_tun_tcp) = { 187 { ICE_MAC_OFOS, 0 }, 188 { ICE_ETYPE_OL, 12 }, 189 { ICE_IPV4_OFOS, 14 }, 190 { ICE_UDP_OF, 34 }, 191 { ICE_VXLAN, 42 }, 192 { ICE_GENEVE, 42 }, 193 { ICE_VXLAN_GPE, 42 }, 194 { ICE_MAC_IL, 50 }, 195 { ICE_ETYPE_IL, 62 }, 196 { ICE_IPV4_IL, 64 }, 197 { ICE_TCP_IL, 84 }, 198 { ICE_PROTOCOL_LAST, 0 }, 199 }; 200 201 ICE_DECLARE_PKT_TEMPLATE(udp_tun_tcp) = { 202 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 203 0x00, 0x00, 0x00, 0x00, 204 0x00, 0x00, 0x00, 0x00, 205 206 0x08, 0x00, /* ICE_ETYPE_OL 12 */ 207 208 0x45, 0x00, 0x00, 0x5a, /* ICE_IPV4_OFOS 14 */ 209 0x00, 0x01, 0x00, 0x00, 210 0x40, 0x11, 0x00, 0x00, 211 0x00, 0x00, 0x00, 0x00, 212 0x00, 0x00, 0x00, 0x00, 213 214 0x00, 0x00, 0x12, 0xb5, /* ICE_UDP_OF 34 */ 215 0x00, 0x46, 0x00, 0x00, 216 217 0x00, 0x00, 0x65, 0x58, /* ICE_VXLAN 42 */ 218 0x00, 0x00, 0x00, 0x00, 219 220 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_IL 50 */ 221 0x00, 0x00, 0x00, 0x00, 222 0x00, 0x00, 0x00, 0x00, 223 224 0x08, 0x00, /* ICE_ETYPE_IL 62 */ 225 226 0x45, 0x00, 0x00, 0x28, /* ICE_IPV4_IL 64 */ 227 0x00, 0x01, 0x00, 0x00, 228 0x40, 0x06, 0x00, 0x00, 229 0x00, 0x00, 0x00, 0x00, 230 0x00, 0x00, 0x00, 0x00, 231 232 0x00, 0x00, 0x00, 0x00, /* ICE_TCP_IL 84 */ 233 0x00, 0x00, 0x00, 0x00, 234 0x00, 0x00, 0x00, 0x00, 235 0x50, 0x02, 0x20, 0x00, 236 0x00, 0x00, 0x00, 0x00 237 }; 238 239 ICE_DECLARE_PKT_OFFSETS(udp_tun_udp) = { 240 { ICE_MAC_OFOS, 0 }, 241 { ICE_ETYPE_OL, 12 }, 242 { ICE_IPV4_OFOS, 14 }, 243 { ICE_UDP_OF, 34 }, 244 { ICE_VXLAN, 42 }, 245 { ICE_GENEVE, 42 }, 246 { ICE_VXLAN_GPE, 42 }, 247 { ICE_MAC_IL, 50 }, 248 { ICE_ETYPE_IL, 62 }, 249 { ICE_IPV4_IL, 64 }, 250 { ICE_UDP_ILOS, 84 }, 251 { ICE_PROTOCOL_LAST, 0 }, 252 }; 253 254 ICE_DECLARE_PKT_TEMPLATE(udp_tun_udp) = { 255 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 256 0x00, 0x00, 0x00, 0x00, 257 0x00, 0x00, 0x00, 0x00, 258 259 0x08, 0x00, /* ICE_ETYPE_OL 12 */ 260 261 0x45, 0x00, 0x00, 0x4e, /* ICE_IPV4_OFOS 14 */ 262 0x00, 0x01, 0x00, 0x00, 263 0x00, 0x11, 0x00, 0x00, 264 0x00, 0x00, 0x00, 0x00, 265 0x00, 0x00, 0x00, 0x00, 266 267 0x00, 0x00, 0x12, 0xb5, /* ICE_UDP_OF 34 */ 268 0x00, 0x3a, 0x00, 0x00, 269 270 0x00, 0x00, 0x65, 0x58, /* ICE_VXLAN 42 */ 271 0x00, 0x00, 0x00, 0x00, 272 273 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_IL 50 */ 274 0x00, 0x00, 0x00, 0x00, 275 0x00, 0x00, 0x00, 0x00, 276 277 0x08, 0x00, /* ICE_ETYPE_IL 62 */ 278 279 0x45, 0x00, 0x00, 0x1c, /* ICE_IPV4_IL 64 */ 280 0x00, 0x01, 0x00, 0x00, 281 0x00, 0x11, 0x00, 0x00, 282 0x00, 0x00, 0x00, 0x00, 283 0x00, 0x00, 0x00, 0x00, 284 285 0x00, 0x00, 0x00, 0x00, /* ICE_UDP_ILOS 84 */ 286 0x00, 0x08, 0x00, 0x00, 287 }; 288 289 ICE_DECLARE_PKT_OFFSETS(gre_ipv6_tcp) = { 290 { ICE_MAC_OFOS, 0 }, 291 { ICE_ETYPE_OL, 12 }, 292 { ICE_IPV4_OFOS, 14 }, 293 { ICE_NVGRE, 34 }, 294 { ICE_MAC_IL, 42 }, 295 { ICE_ETYPE_IL, 54 }, 296 { ICE_IPV6_IL, 56 }, 297 { ICE_TCP_IL, 96 }, 298 { ICE_PROTOCOL_LAST, 0 }, 299 }; 300 301 ICE_DECLARE_PKT_TEMPLATE(gre_ipv6_tcp) = { 302 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 303 0x00, 0x00, 0x00, 0x00, 304 0x00, 0x00, 0x00, 0x00, 305 306 0x08, 0x00, /* ICE_ETYPE_OL 12 */ 307 308 0x45, 0x00, 0x00, 0x66, /* ICE_IPV4_OFOS 14 */ 309 0x00, 0x00, 0x00, 0x00, 310 0x00, 0x2F, 0x00, 0x00, 311 0x00, 0x00, 0x00, 0x00, 312 0x00, 0x00, 0x00, 0x00, 313 314 0x80, 0x00, 0x65, 0x58, /* ICE_NVGRE 34 */ 315 0x00, 0x00, 0x00, 0x00, 316 317 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_IL 42 */ 318 0x00, 0x00, 0x00, 0x00, 319 0x00, 0x00, 0x00, 0x00, 320 321 0x86, 0xdd, /* ICE_ETYPE_IL 54 */ 322 323 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_IL 56 */ 324 0x00, 0x08, 0x06, 0x40, 325 0x00, 0x00, 0x00, 0x00, 326 0x00, 0x00, 0x00, 0x00, 327 0x00, 0x00, 0x00, 0x00, 328 0x00, 0x00, 0x00, 0x00, 329 0x00, 0x00, 0x00, 0x00, 330 0x00, 0x00, 0x00, 0x00, 331 0x00, 0x00, 0x00, 0x00, 332 0x00, 0x00, 0x00, 0x00, 333 334 0x00, 0x00, 0x00, 0x00, /* ICE_TCP_IL 96 */ 335 0x00, 0x00, 0x00, 0x00, 336 0x00, 0x00, 0x00, 0x00, 337 0x50, 0x02, 0x20, 0x00, 338 0x00, 0x00, 0x00, 0x00 339 }; 340 341 ICE_DECLARE_PKT_OFFSETS(gre_ipv6_udp) = { 342 { ICE_MAC_OFOS, 0 }, 343 { ICE_ETYPE_OL, 12 }, 344 { ICE_IPV4_OFOS, 14 }, 345 { ICE_NVGRE, 34 }, 346 { ICE_MAC_IL, 42 }, 347 { ICE_ETYPE_IL, 54 }, 348 { ICE_IPV6_IL, 56 }, 349 { ICE_UDP_ILOS, 96 }, 350 { ICE_PROTOCOL_LAST, 0 }, 351 }; 352 353 ICE_DECLARE_PKT_TEMPLATE(gre_ipv6_udp) = { 354 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 355 0x00, 0x00, 0x00, 0x00, 356 0x00, 0x00, 0x00, 0x00, 357 358 0x08, 0x00, /* ICE_ETYPE_OL 12 */ 359 360 0x45, 0x00, 0x00, 0x5a, /* ICE_IPV4_OFOS 14 */ 361 0x00, 0x00, 0x00, 0x00, 362 0x00, 0x2F, 0x00, 0x00, 363 0x00, 0x00, 0x00, 0x00, 364 0x00, 0x00, 0x00, 0x00, 365 366 0x80, 0x00, 0x65, 0x58, /* ICE_NVGRE 34 */ 367 0x00, 0x00, 0x00, 0x00, 368 369 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_IL 42 */ 370 0x00, 0x00, 0x00, 0x00, 371 0x00, 0x00, 0x00, 0x00, 372 373 0x86, 0xdd, /* ICE_ETYPE_IL 54 */ 374 375 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_IL 56 */ 376 0x00, 0x08, 0x11, 0x40, 377 0x00, 0x00, 0x00, 0x00, 378 0x00, 0x00, 0x00, 0x00, 379 0x00, 0x00, 0x00, 0x00, 380 0x00, 0x00, 0x00, 0x00, 381 0x00, 0x00, 0x00, 0x00, 382 0x00, 0x00, 0x00, 0x00, 383 0x00, 0x00, 0x00, 0x00, 384 0x00, 0x00, 0x00, 0x00, 385 386 0x00, 0x00, 0x00, 0x00, /* ICE_UDP_ILOS 96 */ 387 0x00, 0x08, 0x00, 0x00, 388 }; 389 390 ICE_DECLARE_PKT_OFFSETS(udp_tun_ipv6_tcp) = { 391 { ICE_MAC_OFOS, 0 }, 392 { ICE_ETYPE_OL, 12 }, 393 { ICE_IPV4_OFOS, 14 }, 394 { ICE_UDP_OF, 34 }, 395 { ICE_VXLAN, 42 }, 396 { ICE_GENEVE, 42 }, 397 { ICE_VXLAN_GPE, 42 }, 398 { ICE_MAC_IL, 50 }, 399 { ICE_ETYPE_IL, 62 }, 400 { ICE_IPV6_IL, 64 }, 401 { ICE_TCP_IL, 104 }, 402 { ICE_PROTOCOL_LAST, 0 }, 403 }; 404 405 ICE_DECLARE_PKT_TEMPLATE(udp_tun_ipv6_tcp) = { 406 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 407 0x00, 0x00, 0x00, 0x00, 408 0x00, 0x00, 0x00, 0x00, 409 410 0x08, 0x00, /* ICE_ETYPE_OL 12 */ 411 412 0x45, 0x00, 0x00, 0x6e, /* ICE_IPV4_OFOS 14 */ 413 0x00, 0x01, 0x00, 0x00, 414 0x40, 0x11, 0x00, 0x00, 415 0x00, 0x00, 0x00, 0x00, 416 0x00, 0x00, 0x00, 0x00, 417 418 0x00, 0x00, 0x12, 0xb5, /* ICE_UDP_OF 34 */ 419 0x00, 0x5a, 0x00, 0x00, 420 421 0x00, 0x00, 0x65, 0x58, /* ICE_VXLAN 42 */ 422 0x00, 0x00, 0x00, 0x00, 423 424 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_IL 50 */ 425 0x00, 0x00, 0x00, 0x00, 426 0x00, 0x00, 0x00, 0x00, 427 428 0x86, 0xdd, /* ICE_ETYPE_IL 62 */ 429 430 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_IL 64 */ 431 0x00, 0x08, 0x06, 0x40, 432 0x00, 0x00, 0x00, 0x00, 433 0x00, 0x00, 0x00, 0x00, 434 0x00, 0x00, 0x00, 0x00, 435 0x00, 0x00, 0x00, 0x00, 436 0x00, 0x00, 0x00, 0x00, 437 0x00, 0x00, 0x00, 0x00, 438 0x00, 0x00, 0x00, 0x00, 439 0x00, 0x00, 0x00, 0x00, 440 441 0x00, 0x00, 0x00, 0x00, /* ICE_TCP_IL 104 */ 442 0x00, 0x00, 0x00, 0x00, 443 0x00, 0x00, 0x00, 0x00, 444 0x50, 0x02, 0x20, 0x00, 445 0x00, 0x00, 0x00, 0x00 446 }; 447 448 ICE_DECLARE_PKT_OFFSETS(udp_tun_ipv6_udp) = { 449 { ICE_MAC_OFOS, 0 }, 450 { ICE_ETYPE_OL, 12 }, 451 { ICE_IPV4_OFOS, 14 }, 452 { ICE_UDP_OF, 34 }, 453 { ICE_VXLAN, 42 }, 454 { ICE_GENEVE, 42 }, 455 { ICE_VXLAN_GPE, 42 }, 456 { ICE_MAC_IL, 50 }, 457 { ICE_ETYPE_IL, 62 }, 458 { ICE_IPV6_IL, 64 }, 459 { ICE_UDP_ILOS, 104 }, 460 { ICE_PROTOCOL_LAST, 0 }, 461 }; 462 463 ICE_DECLARE_PKT_TEMPLATE(udp_tun_ipv6_udp) = { 464 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 465 0x00, 0x00, 0x00, 0x00, 466 0x00, 0x00, 0x00, 0x00, 467 468 0x08, 0x00, /* ICE_ETYPE_OL 12 */ 469 470 0x45, 0x00, 0x00, 0x62, /* ICE_IPV4_OFOS 14 */ 471 0x00, 0x01, 0x00, 0x00, 472 0x00, 0x11, 0x00, 0x00, 473 0x00, 0x00, 0x00, 0x00, 474 0x00, 0x00, 0x00, 0x00, 475 476 0x00, 0x00, 0x12, 0xb5, /* ICE_UDP_OF 34 */ 477 0x00, 0x4e, 0x00, 0x00, 478 479 0x00, 0x00, 0x65, 0x58, /* ICE_VXLAN 42 */ 480 0x00, 0x00, 0x00, 0x00, 481 482 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_IL 50 */ 483 0x00, 0x00, 0x00, 0x00, 484 0x00, 0x00, 0x00, 0x00, 485 486 0x86, 0xdd, /* ICE_ETYPE_IL 62 */ 487 488 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_IL 64 */ 489 0x00, 0x08, 0x11, 0x40, 490 0x00, 0x00, 0x00, 0x00, 491 0x00, 0x00, 0x00, 0x00, 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 499 0x00, 0x00, 0x00, 0x00, /* ICE_UDP_ILOS 104 */ 500 0x00, 0x08, 0x00, 0x00, 501 }; 502 503 /* offset info for MAC + IPv4 + UDP dummy packet */ 504 ICE_DECLARE_PKT_OFFSETS(udp) = { 505 { ICE_MAC_OFOS, 0 }, 506 { ICE_ETYPE_OL, 12 }, 507 { ICE_IPV4_OFOS, 14 }, 508 { ICE_UDP_ILOS, 34 }, 509 { ICE_PROTOCOL_LAST, 0 }, 510 }; 511 512 /* Dummy packet for MAC + IPv4 + UDP */ 513 ICE_DECLARE_PKT_TEMPLATE(udp) = { 514 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 515 0x00, 0x00, 0x00, 0x00, 516 0x00, 0x00, 0x00, 0x00, 517 518 0x08, 0x00, /* ICE_ETYPE_OL 12 */ 519 520 0x45, 0x00, 0x00, 0x1c, /* ICE_IPV4_OFOS 14 */ 521 0x00, 0x01, 0x00, 0x00, 522 0x00, 0x11, 0x00, 0x00, 523 0x00, 0x00, 0x00, 0x00, 524 0x00, 0x00, 0x00, 0x00, 525 526 0x00, 0x00, 0x00, 0x00, /* ICE_UDP_ILOS 34 */ 527 0x00, 0x08, 0x00, 0x00, 528 529 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 530 }; 531 532 /* offset info for MAC + IPv4 + TCP dummy packet */ 533 ICE_DECLARE_PKT_OFFSETS(tcp) = { 534 { ICE_MAC_OFOS, 0 }, 535 { ICE_ETYPE_OL, 12 }, 536 { ICE_IPV4_OFOS, 14 }, 537 { ICE_TCP_IL, 34 }, 538 { ICE_PROTOCOL_LAST, 0 }, 539 }; 540 541 /* Dummy packet for MAC + IPv4 + TCP */ 542 ICE_DECLARE_PKT_TEMPLATE(tcp) = { 543 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 544 0x00, 0x00, 0x00, 0x00, 545 0x00, 0x00, 0x00, 0x00, 546 547 0x08, 0x00, /* ICE_ETYPE_OL 12 */ 548 549 0x45, 0x00, 0x00, 0x28, /* ICE_IPV4_OFOS 14 */ 550 0x00, 0x01, 0x00, 0x00, 551 0x00, 0x06, 0x00, 0x00, 552 0x00, 0x00, 0x00, 0x00, 553 0x00, 0x00, 0x00, 0x00, 554 555 0x00, 0x00, 0x00, 0x00, /* ICE_TCP_IL 34 */ 556 0x00, 0x00, 0x00, 0x00, 557 0x00, 0x00, 0x00, 0x00, 558 0x50, 0x00, 0x00, 0x00, 559 0x00, 0x00, 0x00, 0x00, 560 561 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 562 }; 563 564 ICE_DECLARE_PKT_OFFSETS(tcp_ipv6) = { 565 { ICE_MAC_OFOS, 0 }, 566 { ICE_ETYPE_OL, 12 }, 567 { ICE_IPV6_OFOS, 14 }, 568 { ICE_TCP_IL, 54 }, 569 { ICE_PROTOCOL_LAST, 0 }, 570 }; 571 572 ICE_DECLARE_PKT_TEMPLATE(tcp_ipv6) = { 573 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 574 0x00, 0x00, 0x00, 0x00, 575 0x00, 0x00, 0x00, 0x00, 576 577 0x86, 0xDD, /* ICE_ETYPE_OL 12 */ 578 579 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_OFOS 40 */ 580 0x00, 0x14, 0x06, 0x00, /* Next header is TCP */ 581 0x00, 0x00, 0x00, 0x00, 582 0x00, 0x00, 0x00, 0x00, 583 0x00, 0x00, 0x00, 0x00, 584 0x00, 0x00, 0x00, 0x00, 585 0x00, 0x00, 0x00, 0x00, 586 0x00, 0x00, 0x00, 0x00, 587 0x00, 0x00, 0x00, 0x00, 588 0x00, 0x00, 0x00, 0x00, 589 590 0x00, 0x00, 0x00, 0x00, /* ICE_TCP_IL 54 */ 591 0x00, 0x00, 0x00, 0x00, 592 0x00, 0x00, 0x00, 0x00, 593 0x50, 0x00, 0x00, 0x00, 594 0x00, 0x00, 0x00, 0x00, 595 596 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 597 }; 598 599 /* IPv6 + UDP */ 600 ICE_DECLARE_PKT_OFFSETS(udp_ipv6) = { 601 { ICE_MAC_OFOS, 0 }, 602 { ICE_ETYPE_OL, 12 }, 603 { ICE_IPV6_OFOS, 14 }, 604 { ICE_UDP_ILOS, 54 }, 605 { ICE_PROTOCOL_LAST, 0 }, 606 }; 607 608 /* IPv6 + UDP dummy packet */ 609 ICE_DECLARE_PKT_TEMPLATE(udp_ipv6) = { 610 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 611 0x00, 0x00, 0x00, 0x00, 612 0x00, 0x00, 0x00, 0x00, 613 614 0x86, 0xDD, /* ICE_ETYPE_OL 12 */ 615 616 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_OFOS 40 */ 617 0x00, 0x10, 0x11, 0x00, /* Next header UDP */ 618 0x00, 0x00, 0x00, 0x00, 619 0x00, 0x00, 0x00, 0x00, 620 0x00, 0x00, 0x00, 0x00, 621 0x00, 0x00, 0x00, 0x00, 622 0x00, 0x00, 0x00, 0x00, 623 0x00, 0x00, 0x00, 0x00, 624 0x00, 0x00, 0x00, 0x00, 625 0x00, 0x00, 0x00, 0x00, 626 627 0x00, 0x00, 0x00, 0x00, /* ICE_UDP_ILOS 54 */ 628 0x00, 0x10, 0x00, 0x00, 629 630 0x00, 0x00, 0x00, 0x00, /* needed for ESP packets */ 631 0x00, 0x00, 0x00, 0x00, 632 633 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 634 }; 635 636 /* Outer IPv4 + Outer UDP + GTP + Inner IPv4 + Inner TCP */ 637 ICE_DECLARE_PKT_OFFSETS(ipv4_gtpu_ipv4_tcp) = { 638 { ICE_MAC_OFOS, 0 }, 639 { ICE_IPV4_OFOS, 14 }, 640 { ICE_UDP_OF, 34 }, 641 { ICE_GTP, 42 }, 642 { ICE_IPV4_IL, 62 }, 643 { ICE_TCP_IL, 82 }, 644 { ICE_PROTOCOL_LAST, 0 }, 645 }; 646 647 ICE_DECLARE_PKT_TEMPLATE(ipv4_gtpu_ipv4_tcp) = { 648 0x00, 0x00, 0x00, 0x00, /* Ethernet 0 */ 649 0x00, 0x00, 0x00, 0x00, 650 0x00, 0x00, 0x00, 0x00, 651 0x08, 0x00, 652 653 0x45, 0x00, 0x00, 0x58, /* IP 14 */ 654 0x00, 0x00, 0x00, 0x00, 655 0x00, 0x11, 0x00, 0x00, 656 0x00, 0x00, 0x00, 0x00, 657 0x00, 0x00, 0x00, 0x00, 658 659 0x00, 0x00, 0x08, 0x68, /* UDP 34 */ 660 0x00, 0x44, 0x00, 0x00, 661 662 0x34, 0xff, 0x00, 0x34, /* ICE_GTP Header 42 */ 663 0x00, 0x00, 0x00, 0x00, 664 0x00, 0x00, 0x00, 0x85, 665 666 0x02, 0x00, 0x00, 0x00, /* GTP_PDUSession_ExtensionHeader 54 */ 667 0x00, 0x00, 0x00, 0x00, 668 669 0x45, 0x00, 0x00, 0x28, /* IP 62 */ 670 0x00, 0x00, 0x00, 0x00, 671 0x00, 0x06, 0x00, 0x00, 672 0x00, 0x00, 0x00, 0x00, 673 0x00, 0x00, 0x00, 0x00, 674 675 0x00, 0x00, 0x00, 0x00, /* TCP 82 */ 676 0x00, 0x00, 0x00, 0x00, 677 0x00, 0x00, 0x00, 0x00, 678 0x50, 0x00, 0x00, 0x00, 679 0x00, 0x00, 0x00, 0x00, 680 681 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 682 }; 683 684 /* Outer IPv4 + Outer UDP + GTP + Inner IPv4 + Inner UDP */ 685 ICE_DECLARE_PKT_OFFSETS(ipv4_gtpu_ipv4_udp) = { 686 { ICE_MAC_OFOS, 0 }, 687 { ICE_IPV4_OFOS, 14 }, 688 { ICE_UDP_OF, 34 }, 689 { ICE_GTP, 42 }, 690 { ICE_IPV4_IL, 62 }, 691 { ICE_UDP_ILOS, 82 }, 692 { ICE_PROTOCOL_LAST, 0 }, 693 }; 694 695 ICE_DECLARE_PKT_TEMPLATE(ipv4_gtpu_ipv4_udp) = { 696 0x00, 0x00, 0x00, 0x00, /* Ethernet 0 */ 697 0x00, 0x00, 0x00, 0x00, 698 0x00, 0x00, 0x00, 0x00, 699 0x08, 0x00, 700 701 0x45, 0x00, 0x00, 0x4c, /* IP 14 */ 702 0x00, 0x00, 0x00, 0x00, 703 0x00, 0x11, 0x00, 0x00, 704 0x00, 0x00, 0x00, 0x00, 705 0x00, 0x00, 0x00, 0x00, 706 707 0x00, 0x00, 0x08, 0x68, /* UDP 34 */ 708 0x00, 0x38, 0x00, 0x00, 709 710 0x34, 0xff, 0x00, 0x28, /* ICE_GTP Header 42 */ 711 0x00, 0x00, 0x00, 0x00, 712 0x00, 0x00, 0x00, 0x85, 713 714 0x02, 0x00, 0x00, 0x00, /* GTP_PDUSession_ExtensionHeader 54 */ 715 0x00, 0x00, 0x00, 0x00, 716 717 0x45, 0x00, 0x00, 0x1c, /* IP 62 */ 718 0x00, 0x00, 0x00, 0x00, 719 0x00, 0x11, 0x00, 0x00, 720 0x00, 0x00, 0x00, 0x00, 721 0x00, 0x00, 0x00, 0x00, 722 723 0x00, 0x00, 0x00, 0x00, /* UDP 82 */ 724 0x00, 0x08, 0x00, 0x00, 725 726 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 727 }; 728 729 /* Outer IPv6 + Outer UDP + GTP + Inner IPv4 + Inner TCP */ 730 ICE_DECLARE_PKT_OFFSETS(ipv4_gtpu_ipv6_tcp) = { 731 { ICE_MAC_OFOS, 0 }, 732 { ICE_IPV4_OFOS, 14 }, 733 { ICE_UDP_OF, 34 }, 734 { ICE_GTP, 42 }, 735 { ICE_IPV6_IL, 62 }, 736 { ICE_TCP_IL, 102 }, 737 { ICE_PROTOCOL_LAST, 0 }, 738 }; 739 740 ICE_DECLARE_PKT_TEMPLATE(ipv4_gtpu_ipv6_tcp) = { 741 0x00, 0x00, 0x00, 0x00, /* Ethernet 0 */ 742 0x00, 0x00, 0x00, 0x00, 743 0x00, 0x00, 0x00, 0x00, 744 0x08, 0x00, 745 746 0x45, 0x00, 0x00, 0x6c, /* IP 14 */ 747 0x00, 0x00, 0x00, 0x00, 748 0x00, 0x11, 0x00, 0x00, 749 0x00, 0x00, 0x00, 0x00, 750 0x00, 0x00, 0x00, 0x00, 751 752 0x00, 0x00, 0x08, 0x68, /* UDP 34 */ 753 0x00, 0x58, 0x00, 0x00, 754 755 0x34, 0xff, 0x00, 0x48, /* ICE_GTP Header 42 */ 756 0x00, 0x00, 0x00, 0x00, 757 0x00, 0x00, 0x00, 0x85, 758 759 0x02, 0x00, 0x00, 0x00, /* GTP_PDUSession_ExtensionHeader 54 */ 760 0x00, 0x00, 0x00, 0x00, 761 762 0x60, 0x00, 0x00, 0x00, /* IPv6 62 */ 763 0x00, 0x14, 0x06, 0x00, 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, /* TCP 102 */ 774 0x00, 0x00, 0x00, 0x00, 775 0x00, 0x00, 0x00, 0x00, 776 0x50, 0x00, 0x00, 0x00, 777 0x00, 0x00, 0x00, 0x00, 778 779 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 780 }; 781 782 ICE_DECLARE_PKT_OFFSETS(ipv4_gtpu_ipv6_udp) = { 783 { ICE_MAC_OFOS, 0 }, 784 { ICE_IPV4_OFOS, 14 }, 785 { ICE_UDP_OF, 34 }, 786 { ICE_GTP, 42 }, 787 { ICE_IPV6_IL, 62 }, 788 { ICE_UDP_ILOS, 102 }, 789 { ICE_PROTOCOL_LAST, 0 }, 790 }; 791 792 ICE_DECLARE_PKT_TEMPLATE(ipv4_gtpu_ipv6_udp) = { 793 0x00, 0x00, 0x00, 0x00, /* Ethernet 0 */ 794 0x00, 0x00, 0x00, 0x00, 795 0x00, 0x00, 0x00, 0x00, 796 0x08, 0x00, 797 798 0x45, 0x00, 0x00, 0x60, /* IP 14 */ 799 0x00, 0x00, 0x00, 0x00, 800 0x00, 0x11, 0x00, 0x00, 801 0x00, 0x00, 0x00, 0x00, 802 0x00, 0x00, 0x00, 0x00, 803 804 0x00, 0x00, 0x08, 0x68, /* UDP 34 */ 805 0x00, 0x4c, 0x00, 0x00, 806 807 0x34, 0xff, 0x00, 0x3c, /* ICE_GTP Header 42 */ 808 0x00, 0x00, 0x00, 0x00, 809 0x00, 0x00, 0x00, 0x85, 810 811 0x02, 0x00, 0x00, 0x00, /* GTP_PDUSession_ExtensionHeader 54 */ 812 0x00, 0x00, 0x00, 0x00, 813 814 0x60, 0x00, 0x00, 0x00, /* IPv6 62 */ 815 0x00, 0x08, 0x11, 0x00, 816 0x00, 0x00, 0x00, 0x00, 817 0x00, 0x00, 0x00, 0x00, 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 825 0x00, 0x00, 0x00, 0x00, /* UDP 102 */ 826 0x00, 0x08, 0x00, 0x00, 827 828 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 829 }; 830 831 ICE_DECLARE_PKT_OFFSETS(ipv6_gtpu_ipv4_tcp) = { 832 { ICE_MAC_OFOS, 0 }, 833 { ICE_IPV6_OFOS, 14 }, 834 { ICE_UDP_OF, 54 }, 835 { ICE_GTP, 62 }, 836 { ICE_IPV4_IL, 82 }, 837 { ICE_TCP_IL, 102 }, 838 { ICE_PROTOCOL_LAST, 0 }, 839 }; 840 841 ICE_DECLARE_PKT_TEMPLATE(ipv6_gtpu_ipv4_tcp) = { 842 0x00, 0x00, 0x00, 0x00, /* Ethernet 0 */ 843 0x00, 0x00, 0x00, 0x00, 844 0x00, 0x00, 0x00, 0x00, 845 0x86, 0xdd, 846 847 0x60, 0x00, 0x00, 0x00, /* IPv6 14 */ 848 0x00, 0x44, 0x11, 0x00, 849 0x00, 0x00, 0x00, 0x00, 850 0x00, 0x00, 0x00, 0x00, 851 0x00, 0x00, 0x00, 0x00, 852 0x00, 0x00, 0x00, 0x00, 853 0x00, 0x00, 0x00, 0x00, 854 0x00, 0x00, 0x00, 0x00, 855 0x00, 0x00, 0x00, 0x00, 856 0x00, 0x00, 0x00, 0x00, 857 858 0x00, 0x00, 0x08, 0x68, /* UDP 54 */ 859 0x00, 0x44, 0x00, 0x00, 860 861 0x34, 0xff, 0x00, 0x34, /* ICE_GTP Header 62 */ 862 0x00, 0x00, 0x00, 0x00, 863 0x00, 0x00, 0x00, 0x85, 864 865 0x02, 0x00, 0x00, 0x00, /* GTP_PDUSession_ExtensionHeader 74 */ 866 0x00, 0x00, 0x00, 0x00, 867 868 0x45, 0x00, 0x00, 0x28, /* IP 82 */ 869 0x00, 0x00, 0x00, 0x00, 870 0x00, 0x06, 0x00, 0x00, 871 0x00, 0x00, 0x00, 0x00, 872 0x00, 0x00, 0x00, 0x00, 873 874 0x00, 0x00, 0x00, 0x00, /* TCP 102 */ 875 0x00, 0x00, 0x00, 0x00, 876 0x00, 0x00, 0x00, 0x00, 877 0x50, 0x00, 0x00, 0x00, 878 0x00, 0x00, 0x00, 0x00, 879 880 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 881 }; 882 883 ICE_DECLARE_PKT_OFFSETS(ipv6_gtpu_ipv4_udp) = { 884 { ICE_MAC_OFOS, 0 }, 885 { ICE_IPV6_OFOS, 14 }, 886 { ICE_UDP_OF, 54 }, 887 { ICE_GTP, 62 }, 888 { ICE_IPV4_IL, 82 }, 889 { ICE_UDP_ILOS, 102 }, 890 { ICE_PROTOCOL_LAST, 0 }, 891 }; 892 893 ICE_DECLARE_PKT_TEMPLATE(ipv6_gtpu_ipv4_udp) = { 894 0x00, 0x00, 0x00, 0x00, /* Ethernet 0 */ 895 0x00, 0x00, 0x00, 0x00, 896 0x00, 0x00, 0x00, 0x00, 897 0x86, 0xdd, 898 899 0x60, 0x00, 0x00, 0x00, /* IPv6 14 */ 900 0x00, 0x38, 0x11, 0x00, 901 0x00, 0x00, 0x00, 0x00, 902 0x00, 0x00, 0x00, 0x00, 903 0x00, 0x00, 0x00, 0x00, 904 0x00, 0x00, 0x00, 0x00, 905 0x00, 0x00, 0x00, 0x00, 906 0x00, 0x00, 0x00, 0x00, 907 0x00, 0x00, 0x00, 0x00, 908 0x00, 0x00, 0x00, 0x00, 909 910 0x00, 0x00, 0x08, 0x68, /* UDP 54 */ 911 0x00, 0x38, 0x00, 0x00, 912 913 0x34, 0xff, 0x00, 0x28, /* ICE_GTP Header 62 */ 914 0x00, 0x00, 0x00, 0x00, 915 0x00, 0x00, 0x00, 0x85, 916 917 0x02, 0x00, 0x00, 0x00, /* GTP_PDUSession_ExtensionHeader 74 */ 918 0x00, 0x00, 0x00, 0x00, 919 920 0x45, 0x00, 0x00, 0x1c, /* IP 82 */ 921 0x00, 0x00, 0x00, 0x00, 922 0x00, 0x11, 0x00, 0x00, 923 0x00, 0x00, 0x00, 0x00, 924 0x00, 0x00, 0x00, 0x00, 925 926 0x00, 0x00, 0x00, 0x00, /* UDP 102 */ 927 0x00, 0x08, 0x00, 0x00, 928 929 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 930 }; 931 932 ICE_DECLARE_PKT_OFFSETS(ipv6_gtpu_ipv6_tcp) = { 933 { ICE_MAC_OFOS, 0 }, 934 { ICE_IPV6_OFOS, 14 }, 935 { ICE_UDP_OF, 54 }, 936 { ICE_GTP, 62 }, 937 { ICE_IPV6_IL, 82 }, 938 { ICE_TCP_IL, 122 }, 939 { ICE_PROTOCOL_LAST, 0 }, 940 }; 941 942 ICE_DECLARE_PKT_TEMPLATE(ipv6_gtpu_ipv6_tcp) = { 943 0x00, 0x00, 0x00, 0x00, /* Ethernet 0 */ 944 0x00, 0x00, 0x00, 0x00, 945 0x00, 0x00, 0x00, 0x00, 946 0x86, 0xdd, 947 948 0x60, 0x00, 0x00, 0x00, /* IPv6 14 */ 949 0x00, 0x58, 0x11, 0x00, 950 0x00, 0x00, 0x00, 0x00, 951 0x00, 0x00, 0x00, 0x00, 952 0x00, 0x00, 0x00, 0x00, 953 0x00, 0x00, 0x00, 0x00, 954 0x00, 0x00, 0x00, 0x00, 955 0x00, 0x00, 0x00, 0x00, 956 0x00, 0x00, 0x00, 0x00, 957 0x00, 0x00, 0x00, 0x00, 958 959 0x00, 0x00, 0x08, 0x68, /* UDP 54 */ 960 0x00, 0x58, 0x00, 0x00, 961 962 0x34, 0xff, 0x00, 0x48, /* ICE_GTP Header 62 */ 963 0x00, 0x00, 0x00, 0x00, 964 0x00, 0x00, 0x00, 0x85, 965 966 0x02, 0x00, 0x00, 0x00, /* GTP_PDUSession_ExtensionHeader 74 */ 967 0x00, 0x00, 0x00, 0x00, 968 969 0x60, 0x00, 0x00, 0x00, /* IPv6 82 */ 970 0x00, 0x14, 0x06, 0x00, 971 0x00, 0x00, 0x00, 0x00, 972 0x00, 0x00, 0x00, 0x00, 973 0x00, 0x00, 0x00, 0x00, 974 0x00, 0x00, 0x00, 0x00, 975 0x00, 0x00, 0x00, 0x00, 976 0x00, 0x00, 0x00, 0x00, 977 0x00, 0x00, 0x00, 0x00, 978 0x00, 0x00, 0x00, 0x00, 979 980 0x00, 0x00, 0x00, 0x00, /* TCP 122 */ 981 0x00, 0x00, 0x00, 0x00, 982 0x00, 0x00, 0x00, 0x00, 983 0x50, 0x00, 0x00, 0x00, 984 0x00, 0x00, 0x00, 0x00, 985 986 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 987 }; 988 989 ICE_DECLARE_PKT_OFFSETS(ipv6_gtpu_ipv6_udp) = { 990 { ICE_MAC_OFOS, 0 }, 991 { ICE_IPV6_OFOS, 14 }, 992 { ICE_UDP_OF, 54 }, 993 { ICE_GTP, 62 }, 994 { ICE_IPV6_IL, 82 }, 995 { ICE_UDP_ILOS, 122 }, 996 { ICE_PROTOCOL_LAST, 0 }, 997 }; 998 999 ICE_DECLARE_PKT_TEMPLATE(ipv6_gtpu_ipv6_udp) = { 1000 0x00, 0x00, 0x00, 0x00, /* Ethernet 0 */ 1001 0x00, 0x00, 0x00, 0x00, 1002 0x00, 0x00, 0x00, 0x00, 1003 0x86, 0xdd, 1004 1005 0x60, 0x00, 0x00, 0x00, /* IPv6 14 */ 1006 0x00, 0x4c, 0x11, 0x00, 1007 0x00, 0x00, 0x00, 0x00, 1008 0x00, 0x00, 0x00, 0x00, 1009 0x00, 0x00, 0x00, 0x00, 1010 0x00, 0x00, 0x00, 0x00, 1011 0x00, 0x00, 0x00, 0x00, 1012 0x00, 0x00, 0x00, 0x00, 1013 0x00, 0x00, 0x00, 0x00, 1014 0x00, 0x00, 0x00, 0x00, 1015 1016 0x00, 0x00, 0x08, 0x68, /* UDP 54 */ 1017 0x00, 0x4c, 0x00, 0x00, 1018 1019 0x34, 0xff, 0x00, 0x3c, /* ICE_GTP Header 62 */ 1020 0x00, 0x00, 0x00, 0x00, 1021 0x00, 0x00, 0x00, 0x85, 1022 1023 0x02, 0x00, 0x00, 0x00, /* GTP_PDUSession_ExtensionHeader 74 */ 1024 0x00, 0x00, 0x00, 0x00, 1025 1026 0x60, 0x00, 0x00, 0x00, /* IPv6 82 */ 1027 0x00, 0x08, 0x11, 0x00, 1028 0x00, 0x00, 0x00, 0x00, 1029 0x00, 0x00, 0x00, 0x00, 1030 0x00, 0x00, 0x00, 0x00, 1031 0x00, 0x00, 0x00, 0x00, 1032 0x00, 0x00, 0x00, 0x00, 1033 0x00, 0x00, 0x00, 0x00, 1034 0x00, 0x00, 0x00, 0x00, 1035 0x00, 0x00, 0x00, 0x00, 1036 1037 0x00, 0x00, 0x00, 0x00, /* UDP 122 */ 1038 0x00, 0x08, 0x00, 0x00, 1039 1040 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 1041 }; 1042 1043 ICE_DECLARE_PKT_OFFSETS(ipv4_gtpu_ipv4) = { 1044 { ICE_MAC_OFOS, 0 }, 1045 { ICE_IPV4_OFOS, 14 }, 1046 { ICE_UDP_OF, 34 }, 1047 { ICE_GTP_NO_PAY, 42 }, 1048 { ICE_PROTOCOL_LAST, 0 }, 1049 }; 1050 1051 ICE_DECLARE_PKT_TEMPLATE(ipv4_gtpu_ipv4) = { 1052 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1053 0x00, 0x00, 0x00, 0x00, 1054 0x00, 0x00, 0x00, 0x00, 1055 0x08, 0x00, 1056 1057 0x45, 0x00, 0x00, 0x44, /* ICE_IPV4_OFOS 14 */ 1058 0x00, 0x00, 0x40, 0x00, 1059 0x40, 0x11, 0x00, 0x00, 1060 0x00, 0x00, 0x00, 0x00, 1061 0x00, 0x00, 0x00, 0x00, 1062 1063 0x08, 0x68, 0x08, 0x68, /* ICE_UDP_OF 34 */ 1064 0x00, 0x00, 0x00, 0x00, 1065 1066 0x34, 0xff, 0x00, 0x28, /* ICE_GTP 42 */ 1067 0x00, 0x00, 0x00, 0x00, 1068 0x00, 0x00, 0x00, 0x85, 1069 1070 0x02, 0x00, 0x00, 0x00, /* PDU Session extension header */ 1071 0x00, 0x00, 0x00, 0x00, 1072 1073 0x45, 0x00, 0x00, 0x14, /* ICE_IPV4_IL 62 */ 1074 0x00, 0x00, 0x40, 0x00, 1075 0x40, 0x00, 0x00, 0x00, 1076 0x00, 0x00, 0x00, 0x00, 1077 0x00, 0x00, 0x00, 0x00, 1078 0x00, 0x00, 1079 }; 1080 1081 ICE_DECLARE_PKT_OFFSETS(ipv6_gtp) = { 1082 { ICE_MAC_OFOS, 0 }, 1083 { ICE_IPV6_OFOS, 14 }, 1084 { ICE_UDP_OF, 54 }, 1085 { ICE_GTP_NO_PAY, 62 }, 1086 { ICE_PROTOCOL_LAST, 0 }, 1087 }; 1088 1089 ICE_DECLARE_PKT_TEMPLATE(ipv6_gtp) = { 1090 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1091 0x00, 0x00, 0x00, 0x00, 1092 0x00, 0x00, 0x00, 0x00, 1093 0x86, 0xdd, 1094 1095 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_OFOS 14 */ 1096 0x00, 0x6c, 0x11, 0x00, /* Next header UDP*/ 1097 0x00, 0x00, 0x00, 0x00, 1098 0x00, 0x00, 0x00, 0x00, 1099 0x00, 0x00, 0x00, 0x00, 1100 0x00, 0x00, 0x00, 0x00, 1101 0x00, 0x00, 0x00, 0x00, 1102 0x00, 0x00, 0x00, 0x00, 1103 0x00, 0x00, 0x00, 0x00, 1104 0x00, 0x00, 0x00, 0x00, 1105 1106 0x08, 0x68, 0x08, 0x68, /* ICE_UDP_OF 54 */ 1107 0x00, 0x00, 0x00, 0x00, 1108 1109 0x30, 0x00, 0x00, 0x28, /* ICE_GTP 62 */ 1110 0x00, 0x00, 0x00, 0x00, 1111 1112 0x00, 0x00, 1113 }; 1114 1115 ICE_DECLARE_PKT_OFFSETS(pfcp_session_ipv4) = { 1116 { ICE_MAC_OFOS, 0 }, 1117 { ICE_ETYPE_OL, 12 }, 1118 { ICE_IPV4_OFOS, 14 }, 1119 { ICE_UDP_ILOS, 34 }, 1120 { ICE_PFCP, 42 }, 1121 { ICE_PROTOCOL_LAST, 0 }, 1122 }; 1123 1124 ICE_DECLARE_PKT_TEMPLATE(pfcp_session_ipv4) = { 1125 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1126 0x00, 0x00, 0x00, 0x00, 1127 0x00, 0x00, 0x00, 0x00, 1128 1129 0x08, 0x00, /* ICE_ETYPE_OL 12 */ 1130 1131 0x45, 0x00, 0x00, 0x2c, /* ICE_IPV4_OFOS 14 */ 1132 0x00, 0x01, 0x00, 0x00, 1133 0x00, 0x11, 0x00, 0x00, 1134 0x00, 0x00, 0x00, 0x00, 1135 0x00, 0x00, 0x00, 0x00, 1136 1137 0x00, 0x00, 0x22, 0x65, /* ICE_UDP_ILOS 34 */ 1138 0x00, 0x18, 0x00, 0x00, 1139 1140 0x21, 0x01, 0x00, 0x0c, /* ICE_PFCP 42 */ 1141 0x00, 0x00, 0x00, 0x00, 1142 0x00, 0x00, 0x00, 0x00, 1143 0x00, 0x00, 0x00, 0x00, 1144 1145 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 1146 }; 1147 1148 ICE_DECLARE_PKT_OFFSETS(pfcp_session_ipv6) = { 1149 { ICE_MAC_OFOS, 0 }, 1150 { ICE_ETYPE_OL, 12 }, 1151 { ICE_IPV6_OFOS, 14 }, 1152 { ICE_UDP_ILOS, 54 }, 1153 { ICE_PFCP, 62 }, 1154 { ICE_PROTOCOL_LAST, 0 }, 1155 }; 1156 1157 ICE_DECLARE_PKT_TEMPLATE(pfcp_session_ipv6) = { 1158 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1159 0x00, 0x00, 0x00, 0x00, 1160 0x00, 0x00, 0x00, 0x00, 1161 1162 0x86, 0xdd, /* ICE_ETYPE_OL 12 */ 1163 1164 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_OFOS 14 */ 1165 0x00, 0x10, 0x11, 0x00, /* Next header UDP */ 1166 0x00, 0x00, 0x00, 0x00, 1167 0x00, 0x00, 0x00, 0x00, 1168 0x00, 0x00, 0x00, 0x00, 1169 0x00, 0x00, 0x00, 0x00, 1170 0x00, 0x00, 0x00, 0x00, 1171 0x00, 0x00, 0x00, 0x00, 1172 0x00, 0x00, 0x00, 0x00, 1173 0x00, 0x00, 0x00, 0x00, 1174 1175 0x00, 0x00, 0x22, 0x65, /* ICE_UDP_ILOS 54 */ 1176 0x00, 0x18, 0x00, 0x00, 1177 1178 0x21, 0x01, 0x00, 0x0c, /* ICE_PFCP 62 */ 1179 0x00, 0x00, 0x00, 0x00, 1180 0x00, 0x00, 0x00, 0x00, 1181 0x00, 0x00, 0x00, 0x00, 1182 1183 0x00, 0x00, /* 2 bytes for 4 byte alignment */ 1184 }; 1185 1186 ICE_DECLARE_PKT_OFFSETS(pppoe_ipv4_tcp) = { 1187 { ICE_MAC_OFOS, 0 }, 1188 { ICE_ETYPE_OL, 12 }, 1189 { ICE_PPPOE, 14 }, 1190 { ICE_IPV4_OFOS, 22 }, 1191 { ICE_TCP_IL, 42 }, 1192 { ICE_PROTOCOL_LAST, 0 }, 1193 }; 1194 1195 ICE_DECLARE_PKT_TEMPLATE(pppoe_ipv4_tcp) = { 1196 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1197 0x00, 0x00, 0x00, 0x00, 1198 0x00, 0x00, 0x00, 0x00, 1199 1200 0x88, 0x64, /* ICE_ETYPE_OL 12 */ 1201 1202 0x11, 0x00, 0x00, 0x00, /* ICE_PPPOE 14 */ 1203 0x00, 0x16, 1204 1205 0x00, 0x21, /* PPP Link Layer 20 */ 1206 1207 0x45, 0x00, 0x00, 0x28, /* ICE_IPV4_OFOS 22 */ 1208 0x00, 0x01, 0x00, 0x00, 1209 0x00, 0x06, 0x00, 0x00, 1210 0x00, 0x00, 0x00, 0x00, 1211 0x00, 0x00, 0x00, 0x00, 1212 1213 0x00, 0x00, 0x00, 0x00, /* ICE_TCP_IL 42 */ 1214 0x00, 0x00, 0x00, 0x00, 1215 0x00, 0x00, 0x00, 0x00, 1216 0x50, 0x00, 0x00, 0x00, 1217 0x00, 0x00, 0x00, 0x00, 1218 1219 0x00, 0x00, /* 2 bytes for 4 bytes alignment */ 1220 }; 1221 1222 ICE_DECLARE_PKT_OFFSETS(pppoe_ipv4_udp) = { 1223 { ICE_MAC_OFOS, 0 }, 1224 { ICE_ETYPE_OL, 12 }, 1225 { ICE_PPPOE, 14 }, 1226 { ICE_IPV4_OFOS, 22 }, 1227 { ICE_UDP_ILOS, 42 }, 1228 { ICE_PROTOCOL_LAST, 0 }, 1229 }; 1230 1231 ICE_DECLARE_PKT_TEMPLATE(pppoe_ipv4_udp) = { 1232 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1233 0x00, 0x00, 0x00, 0x00, 1234 0x00, 0x00, 0x00, 0x00, 1235 1236 0x88, 0x64, /* ICE_ETYPE_OL 12 */ 1237 1238 0x11, 0x00, 0x00, 0x00, /* ICE_PPPOE 14 */ 1239 0x00, 0x16, 1240 1241 0x00, 0x21, /* PPP Link Layer 20 */ 1242 1243 0x45, 0x00, 0x00, 0x1c, /* ICE_IPV4_OFOS 22 */ 1244 0x00, 0x01, 0x00, 0x00, 1245 0x00, 0x11, 0x00, 0x00, 1246 0x00, 0x00, 0x00, 0x00, 1247 0x00, 0x00, 0x00, 0x00, 1248 1249 0x00, 0x00, 0x00, 0x00, /* ICE_UDP_ILOS 42 */ 1250 0x00, 0x08, 0x00, 0x00, 1251 1252 0x00, 0x00, /* 2 bytes for 4 bytes alignment */ 1253 }; 1254 1255 ICE_DECLARE_PKT_OFFSETS(pppoe_ipv6_tcp) = { 1256 { ICE_MAC_OFOS, 0 }, 1257 { ICE_ETYPE_OL, 12 }, 1258 { ICE_PPPOE, 14 }, 1259 { ICE_IPV6_OFOS, 22 }, 1260 { ICE_TCP_IL, 62 }, 1261 { ICE_PROTOCOL_LAST, 0 }, 1262 }; 1263 1264 ICE_DECLARE_PKT_TEMPLATE(pppoe_ipv6_tcp) = { 1265 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1266 0x00, 0x00, 0x00, 0x00, 1267 0x00, 0x00, 0x00, 0x00, 1268 1269 0x88, 0x64, /* ICE_ETYPE_OL 12 */ 1270 1271 0x11, 0x00, 0x00, 0x00, /* ICE_PPPOE 14 */ 1272 0x00, 0x2a, 1273 1274 0x00, 0x57, /* PPP Link Layer 20 */ 1275 1276 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_OFOS 22 */ 1277 0x00, 0x14, 0x06, 0x00, /* Next header is TCP */ 1278 0x00, 0x00, 0x00, 0x00, 1279 0x00, 0x00, 0x00, 0x00, 1280 0x00, 0x00, 0x00, 0x00, 1281 0x00, 0x00, 0x00, 0x00, 1282 0x00, 0x00, 0x00, 0x00, 1283 0x00, 0x00, 0x00, 0x00, 1284 0x00, 0x00, 0x00, 0x00, 1285 0x00, 0x00, 0x00, 0x00, 1286 1287 0x00, 0x00, 0x00, 0x00, /* ICE_TCP_IL 62 */ 1288 0x00, 0x00, 0x00, 0x00, 1289 0x00, 0x00, 0x00, 0x00, 1290 0x50, 0x00, 0x00, 0x00, 1291 0x00, 0x00, 0x00, 0x00, 1292 1293 0x00, 0x00, /* 2 bytes for 4 bytes alignment */ 1294 }; 1295 1296 ICE_DECLARE_PKT_OFFSETS(pppoe_ipv6_udp) = { 1297 { ICE_MAC_OFOS, 0 }, 1298 { ICE_ETYPE_OL, 12 }, 1299 { ICE_PPPOE, 14 }, 1300 { ICE_IPV6_OFOS, 22 }, 1301 { ICE_UDP_ILOS, 62 }, 1302 { ICE_PROTOCOL_LAST, 0 }, 1303 }; 1304 1305 ICE_DECLARE_PKT_TEMPLATE(pppoe_ipv6_udp) = { 1306 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1307 0x00, 0x00, 0x00, 0x00, 1308 0x00, 0x00, 0x00, 0x00, 1309 1310 0x88, 0x64, /* ICE_ETYPE_OL 12 */ 1311 1312 0x11, 0x00, 0x00, 0x00, /* ICE_PPPOE 14 */ 1313 0x00, 0x2a, 1314 1315 0x00, 0x57, /* PPP Link Layer 20 */ 1316 1317 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_OFOS 22 */ 1318 0x00, 0x08, 0x11, 0x00, /* Next header UDP*/ 1319 0x00, 0x00, 0x00, 0x00, 1320 0x00, 0x00, 0x00, 0x00, 1321 0x00, 0x00, 0x00, 0x00, 1322 0x00, 0x00, 0x00, 0x00, 1323 0x00, 0x00, 0x00, 0x00, 1324 0x00, 0x00, 0x00, 0x00, 1325 0x00, 0x00, 0x00, 0x00, 1326 0x00, 0x00, 0x00, 0x00, 1327 1328 0x00, 0x00, 0x00, 0x00, /* ICE_UDP_ILOS 62 */ 1329 0x00, 0x08, 0x00, 0x00, 1330 1331 0x00, 0x00, /* 2 bytes for 4 bytes alignment */ 1332 }; 1333 1334 ICE_DECLARE_PKT_OFFSETS(ipv4_l2tpv3) = { 1335 { ICE_MAC_OFOS, 0 }, 1336 { ICE_ETYPE_OL, 12 }, 1337 { ICE_IPV4_OFOS, 14 }, 1338 { ICE_L2TPV3, 34 }, 1339 { ICE_PROTOCOL_LAST, 0 }, 1340 }; 1341 1342 ICE_DECLARE_PKT_TEMPLATE(ipv4_l2tpv3) = { 1343 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1344 0x00, 0x00, 0x00, 0x00, 1345 0x00, 0x00, 0x00, 0x00, 1346 1347 0x08, 0x00, /* ICE_ETYPE_OL 12 */ 1348 1349 0x45, 0x00, 0x00, 0x20, /* ICE_IPV4_IL 14 */ 1350 0x00, 0x00, 0x40, 0x00, 1351 0x40, 0x73, 0x00, 0x00, 1352 0x00, 0x00, 0x00, 0x00, 1353 0x00, 0x00, 0x00, 0x00, 1354 1355 0x00, 0x00, 0x00, 0x00, /* ICE_L2TPV3 34 */ 1356 0x00, 0x00, 0x00, 0x00, 1357 0x00, 0x00, 0x00, 0x00, 1358 0x00, 0x00, /* 2 bytes for 4 bytes alignment */ 1359 }; 1360 1361 ICE_DECLARE_PKT_OFFSETS(ipv6_l2tpv3) = { 1362 { ICE_MAC_OFOS, 0 }, 1363 { ICE_ETYPE_OL, 12 }, 1364 { ICE_IPV6_OFOS, 14 }, 1365 { ICE_L2TPV3, 54 }, 1366 { ICE_PROTOCOL_LAST, 0 }, 1367 }; 1368 1369 ICE_DECLARE_PKT_TEMPLATE(ipv6_l2tpv3) = { 1370 0x00, 0x00, 0x00, 0x00, /* ICE_MAC_OFOS 0 */ 1371 0x00, 0x00, 0x00, 0x00, 1372 0x00, 0x00, 0x00, 0x00, 1373 1374 0x86, 0xDD, /* ICE_ETYPE_OL 12 */ 1375 1376 0x60, 0x00, 0x00, 0x00, /* ICE_IPV6_IL 14 */ 1377 0x00, 0x0c, 0x73, 0x40, 1378 0x00, 0x00, 0x00, 0x00, 1379 0x00, 0x00, 0x00, 0x00, 1380 0x00, 0x00, 0x00, 0x00, 1381 0x00, 0x00, 0x00, 0x00, 1382 0x00, 0x00, 0x00, 0x00, 1383 0x00, 0x00, 0x00, 0x00, 1384 0x00, 0x00, 0x00, 0x00, 1385 0x00, 0x00, 0x00, 0x00, 1386 1387 0x00, 0x00, 0x00, 0x00, /* ICE_L2TPV3 54 */ 1388 0x00, 0x00, 0x00, 0x00, 1389 0x00, 0x00, 0x00, 0x00, 1390 0x00, 0x00, /* 2 bytes for 4 bytes alignment */ 1391 }; 1392 1393 static const struct ice_dummy_pkt_profile ice_dummy_pkt_profiles[] = { 1394 ICE_PKT_PROFILE(ipv6_gtp, ICE_PKT_TUN_GTPU | ICE_PKT_OUTER_IPV6 | 1395 ICE_PKT_GTP_NOPAY), 1396 ICE_PKT_PROFILE(ipv6_gtpu_ipv6_udp, ICE_PKT_TUN_GTPU | 1397 ICE_PKT_OUTER_IPV6 | 1398 ICE_PKT_INNER_IPV6 | 1399 ICE_PKT_INNER_UDP), 1400 ICE_PKT_PROFILE(ipv6_gtpu_ipv6_tcp, ICE_PKT_TUN_GTPU | 1401 ICE_PKT_OUTER_IPV6 | 1402 ICE_PKT_INNER_IPV6), 1403 ICE_PKT_PROFILE(ipv6_gtpu_ipv4_udp, ICE_PKT_TUN_GTPU | 1404 ICE_PKT_OUTER_IPV6 | 1405 ICE_PKT_INNER_UDP), 1406 ICE_PKT_PROFILE(ipv6_gtpu_ipv4_tcp, ICE_PKT_TUN_GTPU | 1407 ICE_PKT_OUTER_IPV6), 1408 ICE_PKT_PROFILE(ipv4_gtpu_ipv4, ICE_PKT_TUN_GTPU | ICE_PKT_GTP_NOPAY), 1409 ICE_PKT_PROFILE(ipv4_gtpu_ipv6_udp, ICE_PKT_TUN_GTPU | 1410 ICE_PKT_INNER_IPV6 | 1411 ICE_PKT_INNER_UDP), 1412 ICE_PKT_PROFILE(ipv4_gtpu_ipv6_tcp, ICE_PKT_TUN_GTPU | 1413 ICE_PKT_INNER_IPV6), 1414 ICE_PKT_PROFILE(ipv4_gtpu_ipv4_udp, ICE_PKT_TUN_GTPU | 1415 ICE_PKT_INNER_UDP), 1416 ICE_PKT_PROFILE(ipv4_gtpu_ipv4_tcp, ICE_PKT_TUN_GTPU), 1417 ICE_PKT_PROFILE(ipv6_gtp, ICE_PKT_TUN_GTPC | ICE_PKT_OUTER_IPV6), 1418 ICE_PKT_PROFILE(ipv4_gtpu_ipv4, ICE_PKT_TUN_GTPC), 1419 ICE_PKT_PROFILE(pfcp_session_ipv6, ICE_PKT_PFCP | ICE_PKT_OUTER_IPV6), 1420 ICE_PKT_PROFILE(pfcp_session_ipv4, ICE_PKT_PFCP), 1421 ICE_PKT_PROFILE(pppoe_ipv6_udp, ICE_PKT_PPPOE | ICE_PKT_OUTER_IPV6 | 1422 ICE_PKT_INNER_UDP), 1423 ICE_PKT_PROFILE(pppoe_ipv6_tcp, ICE_PKT_PPPOE | ICE_PKT_OUTER_IPV6), 1424 ICE_PKT_PROFILE(pppoe_ipv4_udp, ICE_PKT_PPPOE | ICE_PKT_INNER_UDP), 1425 ICE_PKT_PROFILE(pppoe_ipv4_tcp, ICE_PKT_PPPOE), 1426 ICE_PKT_PROFILE(gre_ipv6_tcp, ICE_PKT_TUN_NVGRE | ICE_PKT_INNER_IPV6 | 1427 ICE_PKT_INNER_TCP), 1428 ICE_PKT_PROFILE(gre_tcp, ICE_PKT_TUN_NVGRE | ICE_PKT_INNER_TCP), 1429 ICE_PKT_PROFILE(gre_ipv6_udp, ICE_PKT_TUN_NVGRE | ICE_PKT_INNER_IPV6), 1430 ICE_PKT_PROFILE(gre_udp, ICE_PKT_TUN_NVGRE), 1431 ICE_PKT_PROFILE(udp_tun_ipv6_tcp, ICE_PKT_TUN_UDP | 1432 ICE_PKT_INNER_IPV6 | 1433 ICE_PKT_INNER_TCP), 1434 ICE_PKT_PROFILE(ipv6_l2tpv3, ICE_PKT_L2TPV3 | ICE_PKT_OUTER_IPV6), 1435 ICE_PKT_PROFILE(ipv4_l2tpv3, ICE_PKT_L2TPV3), 1436 ICE_PKT_PROFILE(udp_tun_tcp, ICE_PKT_TUN_UDP | ICE_PKT_INNER_TCP), 1437 ICE_PKT_PROFILE(udp_tun_ipv6_udp, ICE_PKT_TUN_UDP | 1438 ICE_PKT_INNER_IPV6), 1439 ICE_PKT_PROFILE(udp_tun_udp, ICE_PKT_TUN_UDP), 1440 ICE_PKT_PROFILE(udp_ipv6, ICE_PKT_OUTER_IPV6 | ICE_PKT_INNER_UDP), 1441 ICE_PKT_PROFILE(udp, ICE_PKT_INNER_UDP), 1442 ICE_PKT_PROFILE(tcp_ipv6, ICE_PKT_OUTER_IPV6), 1443 ICE_PKT_PROFILE(tcp, 0), 1444 }; 1445 1446 /* this is a recipe to profile association bitmap */ 1447 static DECLARE_BITMAP(recipe_to_profile[ICE_MAX_NUM_RECIPES], 1448 ICE_MAX_NUM_PROFILES); 1449 1450 /* this is a profile to recipe association bitmap */ 1451 static DECLARE_BITMAP(profile_to_recipe[ICE_MAX_NUM_PROFILES], 1452 ICE_MAX_NUM_RECIPES); 1453 1454 /** 1455 * ice_init_def_sw_recp - initialize the recipe book keeping tables 1456 * @hw: pointer to the HW struct 1457 * 1458 * Allocate memory for the entire recipe table and initialize the structures/ 1459 * entries corresponding to basic recipes. 1460 */ 1461 int ice_init_def_sw_recp(struct ice_hw *hw) 1462 { 1463 struct ice_sw_recipe *recps; 1464 u8 i; 1465 1466 recps = devm_kcalloc(ice_hw_to_dev(hw), ICE_MAX_NUM_RECIPES, 1467 sizeof(*recps), GFP_KERNEL); 1468 if (!recps) 1469 return -ENOMEM; 1470 1471 for (i = 0; i < ICE_MAX_NUM_RECIPES; i++) { 1472 recps[i].root_rid = i; 1473 INIT_LIST_HEAD(&recps[i].filt_rules); 1474 INIT_LIST_HEAD(&recps[i].filt_replay_rules); 1475 mutex_init(&recps[i].filt_rule_lock); 1476 } 1477 1478 hw->switch_info->recp_list = recps; 1479 1480 return 0; 1481 } 1482 1483 /** 1484 * ice_aq_get_sw_cfg - get switch configuration 1485 * @hw: pointer to the hardware structure 1486 * @buf: pointer to the result buffer 1487 * @buf_size: length of the buffer available for response 1488 * @req_desc: pointer to requested descriptor 1489 * @num_elems: pointer to number of elements 1490 * @cd: pointer to command details structure or NULL 1491 * 1492 * Get switch configuration (0x0200) to be placed in buf. 1493 * This admin command returns information such as initial VSI/port number 1494 * and switch ID it belongs to. 1495 * 1496 * NOTE: *req_desc is both an input/output parameter. 1497 * The caller of this function first calls this function with *request_desc set 1498 * to 0. If the response from f/w has *req_desc set to 0, all the switch 1499 * configuration information has been returned; if non-zero (meaning not all 1500 * the information was returned), the caller should call this function again 1501 * with *req_desc set to the previous value returned by f/w to get the 1502 * next block of switch configuration information. 1503 * 1504 * *num_elems is output only parameter. This reflects the number of elements 1505 * in response buffer. The caller of this function to use *num_elems while 1506 * parsing the response buffer. 1507 */ 1508 static int 1509 ice_aq_get_sw_cfg(struct ice_hw *hw, struct ice_aqc_get_sw_cfg_resp_elem *buf, 1510 u16 buf_size, u16 *req_desc, u16 *num_elems, 1511 struct ice_sq_cd *cd) 1512 { 1513 struct ice_aqc_get_sw_cfg *cmd; 1514 struct ice_aq_desc desc; 1515 int status; 1516 1517 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_sw_cfg); 1518 cmd = &desc.params.get_sw_conf; 1519 cmd->element = cpu_to_le16(*req_desc); 1520 1521 status = ice_aq_send_cmd(hw, &desc, buf, buf_size, cd); 1522 if (!status) { 1523 *req_desc = le16_to_cpu(cmd->element); 1524 *num_elems = le16_to_cpu(cmd->num_elems); 1525 } 1526 1527 return status; 1528 } 1529 1530 /** 1531 * ice_aq_add_vsi 1532 * @hw: pointer to the HW struct 1533 * @vsi_ctx: pointer to a VSI context struct 1534 * @cd: pointer to command details structure or NULL 1535 * 1536 * Add a VSI context to the hardware (0x0210) 1537 */ 1538 static int 1539 ice_aq_add_vsi(struct ice_hw *hw, struct ice_vsi_ctx *vsi_ctx, 1540 struct ice_sq_cd *cd) 1541 { 1542 struct ice_aqc_add_update_free_vsi_resp *res; 1543 struct ice_aqc_add_get_update_free_vsi *cmd; 1544 struct ice_aq_desc desc; 1545 int status; 1546 1547 cmd = &desc.params.vsi_cmd; 1548 res = &desc.params.add_update_free_vsi_res; 1549 1550 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_add_vsi); 1551 1552 if (!vsi_ctx->alloc_from_pool) 1553 cmd->vsi_num = cpu_to_le16(vsi_ctx->vsi_num | 1554 ICE_AQ_VSI_IS_VALID); 1555 cmd->vf_id = vsi_ctx->vf_num; 1556 1557 cmd->vsi_flags = cpu_to_le16(vsi_ctx->flags); 1558 1559 desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD); 1560 1561 status = ice_aq_send_cmd(hw, &desc, &vsi_ctx->info, 1562 sizeof(vsi_ctx->info), cd); 1563 1564 if (!status) { 1565 vsi_ctx->vsi_num = le16_to_cpu(res->vsi_num) & ICE_AQ_VSI_NUM_M; 1566 vsi_ctx->vsis_allocd = le16_to_cpu(res->vsi_used); 1567 vsi_ctx->vsis_unallocated = le16_to_cpu(res->vsi_free); 1568 } 1569 1570 return status; 1571 } 1572 1573 /** 1574 * ice_aq_free_vsi 1575 * @hw: pointer to the HW struct 1576 * @vsi_ctx: pointer to a VSI context struct 1577 * @keep_vsi_alloc: keep VSI allocation as part of this PF's resources 1578 * @cd: pointer to command details structure or NULL 1579 * 1580 * Free VSI context info from hardware (0x0213) 1581 */ 1582 static int 1583 ice_aq_free_vsi(struct ice_hw *hw, struct ice_vsi_ctx *vsi_ctx, 1584 bool keep_vsi_alloc, struct ice_sq_cd *cd) 1585 { 1586 struct ice_aqc_add_update_free_vsi_resp *resp; 1587 struct ice_aqc_add_get_update_free_vsi *cmd; 1588 struct ice_aq_desc desc; 1589 int status; 1590 1591 cmd = &desc.params.vsi_cmd; 1592 resp = &desc.params.add_update_free_vsi_res; 1593 1594 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_free_vsi); 1595 1596 cmd->vsi_num = cpu_to_le16(vsi_ctx->vsi_num | ICE_AQ_VSI_IS_VALID); 1597 if (keep_vsi_alloc) 1598 cmd->cmd_flags = cpu_to_le16(ICE_AQ_VSI_KEEP_ALLOC); 1599 1600 status = ice_aq_send_cmd(hw, &desc, NULL, 0, cd); 1601 if (!status) { 1602 vsi_ctx->vsis_allocd = le16_to_cpu(resp->vsi_used); 1603 vsi_ctx->vsis_unallocated = le16_to_cpu(resp->vsi_free); 1604 } 1605 1606 return status; 1607 } 1608 1609 /** 1610 * ice_aq_update_vsi 1611 * @hw: pointer to the HW struct 1612 * @vsi_ctx: pointer to a VSI context struct 1613 * @cd: pointer to command details structure or NULL 1614 * 1615 * Update VSI context in the hardware (0x0211) 1616 */ 1617 static int 1618 ice_aq_update_vsi(struct ice_hw *hw, struct ice_vsi_ctx *vsi_ctx, 1619 struct ice_sq_cd *cd) 1620 { 1621 struct ice_aqc_add_update_free_vsi_resp *resp; 1622 struct ice_aqc_add_get_update_free_vsi *cmd; 1623 struct ice_aq_desc desc; 1624 int status; 1625 1626 cmd = &desc.params.vsi_cmd; 1627 resp = &desc.params.add_update_free_vsi_res; 1628 1629 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_update_vsi); 1630 1631 cmd->vsi_num = cpu_to_le16(vsi_ctx->vsi_num | ICE_AQ_VSI_IS_VALID); 1632 1633 desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD); 1634 1635 status = ice_aq_send_cmd(hw, &desc, &vsi_ctx->info, 1636 sizeof(vsi_ctx->info), cd); 1637 1638 if (!status) { 1639 vsi_ctx->vsis_allocd = le16_to_cpu(resp->vsi_used); 1640 vsi_ctx->vsis_unallocated = le16_to_cpu(resp->vsi_free); 1641 } 1642 1643 return status; 1644 } 1645 1646 /** 1647 * ice_is_vsi_valid - check whether the VSI is valid or not 1648 * @hw: pointer to the HW struct 1649 * @vsi_handle: VSI handle 1650 * 1651 * check whether the VSI is valid or not 1652 */ 1653 bool ice_is_vsi_valid(struct ice_hw *hw, u16 vsi_handle) 1654 { 1655 return vsi_handle < ICE_MAX_VSI && hw->vsi_ctx[vsi_handle]; 1656 } 1657 1658 /** 1659 * ice_get_hw_vsi_num - return the HW VSI number 1660 * @hw: pointer to the HW struct 1661 * @vsi_handle: VSI handle 1662 * 1663 * return the HW VSI number 1664 * Caution: call this function only if VSI is valid (ice_is_vsi_valid) 1665 */ 1666 u16 ice_get_hw_vsi_num(struct ice_hw *hw, u16 vsi_handle) 1667 { 1668 return hw->vsi_ctx[vsi_handle]->vsi_num; 1669 } 1670 1671 /** 1672 * ice_get_vsi_ctx - return the VSI context entry for a given VSI handle 1673 * @hw: pointer to the HW struct 1674 * @vsi_handle: VSI handle 1675 * 1676 * return the VSI context entry for a given VSI handle 1677 */ 1678 struct ice_vsi_ctx *ice_get_vsi_ctx(struct ice_hw *hw, u16 vsi_handle) 1679 { 1680 return (vsi_handle >= ICE_MAX_VSI) ? NULL : hw->vsi_ctx[vsi_handle]; 1681 } 1682 1683 /** 1684 * ice_save_vsi_ctx - save the VSI context for a given VSI handle 1685 * @hw: pointer to the HW struct 1686 * @vsi_handle: VSI handle 1687 * @vsi: VSI context pointer 1688 * 1689 * save the VSI context entry for a given VSI handle 1690 */ 1691 static void 1692 ice_save_vsi_ctx(struct ice_hw *hw, u16 vsi_handle, struct ice_vsi_ctx *vsi) 1693 { 1694 hw->vsi_ctx[vsi_handle] = vsi; 1695 } 1696 1697 /** 1698 * ice_clear_vsi_q_ctx - clear VSI queue contexts for all TCs 1699 * @hw: pointer to the HW struct 1700 * @vsi_handle: VSI handle 1701 */ 1702 static void ice_clear_vsi_q_ctx(struct ice_hw *hw, u16 vsi_handle) 1703 { 1704 struct ice_vsi_ctx *vsi = ice_get_vsi_ctx(hw, vsi_handle); 1705 u8 i; 1706 1707 if (!vsi) 1708 return; 1709 ice_for_each_traffic_class(i) { 1710 devm_kfree(ice_hw_to_dev(hw), vsi->lan_q_ctx[i]); 1711 vsi->lan_q_ctx[i] = NULL; 1712 devm_kfree(ice_hw_to_dev(hw), vsi->rdma_q_ctx[i]); 1713 vsi->rdma_q_ctx[i] = NULL; 1714 } 1715 } 1716 1717 /** 1718 * ice_clear_vsi_ctx - clear the VSI context entry 1719 * @hw: pointer to the HW struct 1720 * @vsi_handle: VSI handle 1721 * 1722 * clear the VSI context entry 1723 */ 1724 static void ice_clear_vsi_ctx(struct ice_hw *hw, u16 vsi_handle) 1725 { 1726 struct ice_vsi_ctx *vsi; 1727 1728 vsi = ice_get_vsi_ctx(hw, vsi_handle); 1729 if (vsi) { 1730 ice_clear_vsi_q_ctx(hw, vsi_handle); 1731 devm_kfree(ice_hw_to_dev(hw), vsi); 1732 hw->vsi_ctx[vsi_handle] = NULL; 1733 } 1734 } 1735 1736 /** 1737 * ice_clear_all_vsi_ctx - clear all the VSI context entries 1738 * @hw: pointer to the HW struct 1739 */ 1740 void ice_clear_all_vsi_ctx(struct ice_hw *hw) 1741 { 1742 u16 i; 1743 1744 for (i = 0; i < ICE_MAX_VSI; i++) 1745 ice_clear_vsi_ctx(hw, i); 1746 } 1747 1748 /** 1749 * ice_add_vsi - add VSI context to the hardware and VSI handle list 1750 * @hw: pointer to the HW struct 1751 * @vsi_handle: unique VSI handle provided by drivers 1752 * @vsi_ctx: pointer to a VSI context struct 1753 * @cd: pointer to command details structure or NULL 1754 * 1755 * Add a VSI context to the hardware also add it into the VSI handle list. 1756 * If this function gets called after reset for existing VSIs then update 1757 * with the new HW VSI number in the corresponding VSI handle list entry. 1758 */ 1759 int 1760 ice_add_vsi(struct ice_hw *hw, u16 vsi_handle, struct ice_vsi_ctx *vsi_ctx, 1761 struct ice_sq_cd *cd) 1762 { 1763 struct ice_vsi_ctx *tmp_vsi_ctx; 1764 int status; 1765 1766 if (vsi_handle >= ICE_MAX_VSI) 1767 return -EINVAL; 1768 status = ice_aq_add_vsi(hw, vsi_ctx, cd); 1769 if (status) 1770 return status; 1771 tmp_vsi_ctx = ice_get_vsi_ctx(hw, vsi_handle); 1772 if (!tmp_vsi_ctx) { 1773 /* Create a new VSI context */ 1774 tmp_vsi_ctx = devm_kzalloc(ice_hw_to_dev(hw), 1775 sizeof(*tmp_vsi_ctx), GFP_KERNEL); 1776 if (!tmp_vsi_ctx) { 1777 ice_aq_free_vsi(hw, vsi_ctx, false, cd); 1778 return -ENOMEM; 1779 } 1780 *tmp_vsi_ctx = *vsi_ctx; 1781 ice_save_vsi_ctx(hw, vsi_handle, tmp_vsi_ctx); 1782 } else { 1783 /* update with new HW VSI num */ 1784 tmp_vsi_ctx->vsi_num = vsi_ctx->vsi_num; 1785 } 1786 1787 return 0; 1788 } 1789 1790 /** 1791 * ice_free_vsi- free VSI context from hardware and VSI handle list 1792 * @hw: pointer to the HW struct 1793 * @vsi_handle: unique VSI handle 1794 * @vsi_ctx: pointer to a VSI context struct 1795 * @keep_vsi_alloc: keep VSI allocation as part of this PF's resources 1796 * @cd: pointer to command details structure or NULL 1797 * 1798 * Free VSI context info from hardware as well as from VSI handle list 1799 */ 1800 int 1801 ice_free_vsi(struct ice_hw *hw, u16 vsi_handle, struct ice_vsi_ctx *vsi_ctx, 1802 bool keep_vsi_alloc, struct ice_sq_cd *cd) 1803 { 1804 int status; 1805 1806 if (!ice_is_vsi_valid(hw, vsi_handle)) 1807 return -EINVAL; 1808 vsi_ctx->vsi_num = ice_get_hw_vsi_num(hw, vsi_handle); 1809 status = ice_aq_free_vsi(hw, vsi_ctx, keep_vsi_alloc, cd); 1810 if (!status) 1811 ice_clear_vsi_ctx(hw, vsi_handle); 1812 return status; 1813 } 1814 1815 /** 1816 * ice_update_vsi 1817 * @hw: pointer to the HW struct 1818 * @vsi_handle: unique VSI handle 1819 * @vsi_ctx: pointer to a VSI context struct 1820 * @cd: pointer to command details structure or NULL 1821 * 1822 * Update VSI context in the hardware 1823 */ 1824 int 1825 ice_update_vsi(struct ice_hw *hw, u16 vsi_handle, struct ice_vsi_ctx *vsi_ctx, 1826 struct ice_sq_cd *cd) 1827 { 1828 if (!ice_is_vsi_valid(hw, vsi_handle)) 1829 return -EINVAL; 1830 vsi_ctx->vsi_num = ice_get_hw_vsi_num(hw, vsi_handle); 1831 return ice_aq_update_vsi(hw, vsi_ctx, cd); 1832 } 1833 1834 /** 1835 * ice_cfg_rdma_fltr - enable/disable RDMA filtering on VSI 1836 * @hw: pointer to HW struct 1837 * @vsi_handle: VSI SW index 1838 * @enable: boolean for enable/disable 1839 */ 1840 int 1841 ice_cfg_rdma_fltr(struct ice_hw *hw, u16 vsi_handle, bool enable) 1842 { 1843 struct ice_vsi_ctx *ctx, *cached_ctx; 1844 int status; 1845 1846 cached_ctx = ice_get_vsi_ctx(hw, vsi_handle); 1847 if (!cached_ctx) 1848 return -ENOENT; 1849 1850 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); 1851 if (!ctx) 1852 return -ENOMEM; 1853 1854 ctx->info.q_opt_rss = cached_ctx->info.q_opt_rss; 1855 ctx->info.q_opt_tc = cached_ctx->info.q_opt_tc; 1856 ctx->info.q_opt_flags = cached_ctx->info.q_opt_flags; 1857 1858 ctx->info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_Q_OPT_VALID); 1859 1860 if (enable) 1861 ctx->info.q_opt_flags |= ICE_AQ_VSI_Q_OPT_PE_FLTR_EN; 1862 else 1863 ctx->info.q_opt_flags &= ~ICE_AQ_VSI_Q_OPT_PE_FLTR_EN; 1864 1865 status = ice_update_vsi(hw, vsi_handle, ctx, NULL); 1866 if (!status) { 1867 cached_ctx->info.q_opt_flags = ctx->info.q_opt_flags; 1868 cached_ctx->info.valid_sections |= ctx->info.valid_sections; 1869 } 1870 1871 kfree(ctx); 1872 return status; 1873 } 1874 1875 /** 1876 * ice_aq_alloc_free_vsi_list 1877 * @hw: pointer to the HW struct 1878 * @vsi_list_id: VSI list ID returned or used for lookup 1879 * @lkup_type: switch rule filter lookup type 1880 * @opc: switch rules population command type - pass in the command opcode 1881 * 1882 * allocates or free a VSI list resource 1883 */ 1884 static int 1885 ice_aq_alloc_free_vsi_list(struct ice_hw *hw, u16 *vsi_list_id, 1886 enum ice_sw_lkup_type lkup_type, 1887 enum ice_adminq_opc opc) 1888 { 1889 DEFINE_RAW_FLEX(struct ice_aqc_alloc_free_res_elem, sw_buf, elem, 1); 1890 u16 buf_len = __struct_size(sw_buf); 1891 struct ice_aqc_res_elem *vsi_ele; 1892 int status; 1893 1894 sw_buf->num_elems = cpu_to_le16(1); 1895 1896 if (lkup_type == ICE_SW_LKUP_MAC || 1897 lkup_type == ICE_SW_LKUP_MAC_VLAN || 1898 lkup_type == ICE_SW_LKUP_ETHERTYPE || 1899 lkup_type == ICE_SW_LKUP_ETHERTYPE_MAC || 1900 lkup_type == ICE_SW_LKUP_PROMISC || 1901 lkup_type == ICE_SW_LKUP_PROMISC_VLAN || 1902 lkup_type == ICE_SW_LKUP_DFLT || 1903 lkup_type == ICE_SW_LKUP_LAST) { 1904 sw_buf->res_type = cpu_to_le16(ICE_AQC_RES_TYPE_VSI_LIST_REP); 1905 } else if (lkup_type == ICE_SW_LKUP_VLAN) { 1906 if (opc == ice_aqc_opc_alloc_res) 1907 sw_buf->res_type = 1908 cpu_to_le16(ICE_AQC_RES_TYPE_VSI_LIST_PRUNE | 1909 ICE_AQC_RES_TYPE_FLAG_SHARED); 1910 else 1911 sw_buf->res_type = 1912 cpu_to_le16(ICE_AQC_RES_TYPE_VSI_LIST_PRUNE); 1913 } else { 1914 return -EINVAL; 1915 } 1916 1917 if (opc == ice_aqc_opc_free_res) 1918 sw_buf->elem[0].e.sw_resp = cpu_to_le16(*vsi_list_id); 1919 1920 status = ice_aq_alloc_free_res(hw, sw_buf, buf_len, opc); 1921 if (status) 1922 return status; 1923 1924 if (opc == ice_aqc_opc_alloc_res) { 1925 vsi_ele = &sw_buf->elem[0]; 1926 *vsi_list_id = le16_to_cpu(vsi_ele->e.sw_resp); 1927 } 1928 1929 return 0; 1930 } 1931 1932 /** 1933 * ice_aq_sw_rules - add/update/remove switch rules 1934 * @hw: pointer to the HW struct 1935 * @rule_list: pointer to switch rule population list 1936 * @rule_list_sz: total size of the rule list in bytes 1937 * @num_rules: number of switch rules in the rule_list 1938 * @opc: switch rules population command type - pass in the command opcode 1939 * @cd: pointer to command details structure or NULL 1940 * 1941 * Add(0x02a0)/Update(0x02a1)/Remove(0x02a2) switch rules commands to firmware 1942 */ 1943 int 1944 ice_aq_sw_rules(struct ice_hw *hw, void *rule_list, u16 rule_list_sz, 1945 u8 num_rules, enum ice_adminq_opc opc, struct ice_sq_cd *cd) 1946 { 1947 struct ice_aq_desc desc; 1948 int status; 1949 1950 if (opc != ice_aqc_opc_add_sw_rules && 1951 opc != ice_aqc_opc_update_sw_rules && 1952 opc != ice_aqc_opc_remove_sw_rules) 1953 return -EINVAL; 1954 1955 ice_fill_dflt_direct_cmd_desc(&desc, opc); 1956 1957 desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD); 1958 desc.params.sw_rules.num_rules_fltr_entry_index = 1959 cpu_to_le16(num_rules); 1960 status = ice_aq_send_cmd(hw, &desc, rule_list, rule_list_sz, cd); 1961 if (opc != ice_aqc_opc_add_sw_rules && 1962 hw->adminq.sq_last_status == ICE_AQ_RC_ENOENT) 1963 status = -ENOENT; 1964 1965 if (!status) { 1966 if (opc == ice_aqc_opc_add_sw_rules) 1967 hw->switch_info->rule_cnt += num_rules; 1968 else if (opc == ice_aqc_opc_remove_sw_rules) 1969 hw->switch_info->rule_cnt -= num_rules; 1970 } 1971 1972 trace_ice_aq_sw_rules(hw->switch_info); 1973 1974 return status; 1975 } 1976 1977 /** 1978 * ice_aq_add_recipe - add switch recipe 1979 * @hw: pointer to the HW struct 1980 * @s_recipe_list: pointer to switch rule population list 1981 * @num_recipes: number of switch recipes in the list 1982 * @cd: pointer to command details structure or NULL 1983 * 1984 * Add(0x0290) 1985 */ 1986 int 1987 ice_aq_add_recipe(struct ice_hw *hw, 1988 struct ice_aqc_recipe_data_elem *s_recipe_list, 1989 u16 num_recipes, struct ice_sq_cd *cd) 1990 { 1991 struct ice_aqc_add_get_recipe *cmd; 1992 struct ice_aq_desc desc; 1993 u16 buf_size; 1994 1995 cmd = &desc.params.add_get_recipe; 1996 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_add_recipe); 1997 1998 cmd->num_sub_recipes = cpu_to_le16(num_recipes); 1999 desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD); 2000 2001 buf_size = num_recipes * sizeof(*s_recipe_list); 2002 2003 return ice_aq_send_cmd(hw, &desc, s_recipe_list, buf_size, cd); 2004 } 2005 2006 /** 2007 * ice_aq_get_recipe - get switch recipe 2008 * @hw: pointer to the HW struct 2009 * @s_recipe_list: pointer to switch rule population list 2010 * @num_recipes: pointer to the number of recipes (input and output) 2011 * @recipe_root: root recipe number of recipe(s) to retrieve 2012 * @cd: pointer to command details structure or NULL 2013 * 2014 * Get(0x0292) 2015 * 2016 * On input, *num_recipes should equal the number of entries in s_recipe_list. 2017 * On output, *num_recipes will equal the number of entries returned in 2018 * s_recipe_list. 2019 * 2020 * The caller must supply enough space in s_recipe_list to hold all possible 2021 * recipes and *num_recipes must equal ICE_MAX_NUM_RECIPES. 2022 */ 2023 int 2024 ice_aq_get_recipe(struct ice_hw *hw, 2025 struct ice_aqc_recipe_data_elem *s_recipe_list, 2026 u16 *num_recipes, u16 recipe_root, struct ice_sq_cd *cd) 2027 { 2028 struct ice_aqc_add_get_recipe *cmd; 2029 struct ice_aq_desc desc; 2030 u16 buf_size; 2031 int status; 2032 2033 if (*num_recipes != ICE_MAX_NUM_RECIPES) 2034 return -EINVAL; 2035 2036 cmd = &desc.params.add_get_recipe; 2037 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_recipe); 2038 2039 cmd->return_index = cpu_to_le16(recipe_root); 2040 cmd->num_sub_recipes = 0; 2041 2042 buf_size = *num_recipes * sizeof(*s_recipe_list); 2043 2044 status = ice_aq_send_cmd(hw, &desc, s_recipe_list, buf_size, cd); 2045 *num_recipes = le16_to_cpu(cmd->num_sub_recipes); 2046 2047 return status; 2048 } 2049 2050 /** 2051 * ice_update_recipe_lkup_idx - update a default recipe based on the lkup_idx 2052 * @hw: pointer to the HW struct 2053 * @params: parameters used to update the default recipe 2054 * 2055 * This function only supports updating default recipes and it only supports 2056 * updating a single recipe based on the lkup_idx at a time. 2057 * 2058 * This is done as a read-modify-write operation. First, get the current recipe 2059 * contents based on the recipe's ID. Then modify the field vector index and 2060 * mask if it's valid at the lkup_idx. Finally, use the add recipe AQ to update 2061 * the pre-existing recipe with the modifications. 2062 */ 2063 int 2064 ice_update_recipe_lkup_idx(struct ice_hw *hw, 2065 struct ice_update_recipe_lkup_idx_params *params) 2066 { 2067 struct ice_aqc_recipe_data_elem *rcp_list; 2068 u16 num_recps = ICE_MAX_NUM_RECIPES; 2069 int status; 2070 2071 rcp_list = kcalloc(num_recps, sizeof(*rcp_list), GFP_KERNEL); 2072 if (!rcp_list) 2073 return -ENOMEM; 2074 2075 /* read current recipe list from firmware */ 2076 rcp_list->recipe_indx = params->rid; 2077 status = ice_aq_get_recipe(hw, rcp_list, &num_recps, params->rid, NULL); 2078 if (status) { 2079 ice_debug(hw, ICE_DBG_SW, "Failed to get recipe %d, status %d\n", 2080 params->rid, status); 2081 goto error_out; 2082 } 2083 2084 /* only modify existing recipe's lkup_idx and mask if valid, while 2085 * leaving all other fields the same, then update the recipe firmware 2086 */ 2087 rcp_list->content.lkup_indx[params->lkup_idx] = params->fv_idx; 2088 if (params->mask_valid) 2089 rcp_list->content.mask[params->lkup_idx] = 2090 cpu_to_le16(params->mask); 2091 2092 if (params->ignore_valid) 2093 rcp_list->content.lkup_indx[params->lkup_idx] |= 2094 ICE_AQ_RECIPE_LKUP_IGNORE; 2095 2096 status = ice_aq_add_recipe(hw, &rcp_list[0], 1, NULL); 2097 if (status) 2098 ice_debug(hw, ICE_DBG_SW, "Failed to update recipe %d lkup_idx %d fv_idx %d mask %d mask_valid %s, status %d\n", 2099 params->rid, params->lkup_idx, params->fv_idx, 2100 params->mask, params->mask_valid ? "true" : "false", 2101 status); 2102 2103 error_out: 2104 kfree(rcp_list); 2105 return status; 2106 } 2107 2108 /** 2109 * ice_aq_map_recipe_to_profile - Map recipe to packet profile 2110 * @hw: pointer to the HW struct 2111 * @profile_id: package profile ID to associate the recipe with 2112 * @r_assoc: Recipe bitmap filled in and need to be returned as response 2113 * @cd: pointer to command details structure or NULL 2114 * Recipe to profile association (0x0291) 2115 */ 2116 int 2117 ice_aq_map_recipe_to_profile(struct ice_hw *hw, u32 profile_id, u64 r_assoc, 2118 struct ice_sq_cd *cd) 2119 { 2120 struct ice_aqc_recipe_to_profile *cmd; 2121 struct ice_aq_desc desc; 2122 2123 cmd = &desc.params.recipe_to_profile; 2124 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_recipe_to_profile); 2125 cmd->profile_id = cpu_to_le16(profile_id); 2126 /* Set the recipe ID bit in the bitmask to let the device know which 2127 * profile we are associating the recipe to 2128 */ 2129 cmd->recipe_assoc = cpu_to_le64(r_assoc); 2130 2131 return ice_aq_send_cmd(hw, &desc, NULL, 0, cd); 2132 } 2133 2134 /** 2135 * ice_aq_get_recipe_to_profile - Map recipe to packet profile 2136 * @hw: pointer to the HW struct 2137 * @profile_id: package profile ID to associate the recipe with 2138 * @r_assoc: Recipe bitmap filled in and need to be returned as response 2139 * @cd: pointer to command details structure or NULL 2140 * Associate profile ID with given recipe (0x0293) 2141 */ 2142 int 2143 ice_aq_get_recipe_to_profile(struct ice_hw *hw, u32 profile_id, u64 *r_assoc, 2144 struct ice_sq_cd *cd) 2145 { 2146 struct ice_aqc_recipe_to_profile *cmd; 2147 struct ice_aq_desc desc; 2148 int status; 2149 2150 cmd = &desc.params.recipe_to_profile; 2151 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_recipe_to_profile); 2152 cmd->profile_id = cpu_to_le16(profile_id); 2153 2154 status = ice_aq_send_cmd(hw, &desc, NULL, 0, cd); 2155 if (!status) 2156 *r_assoc = le64_to_cpu(cmd->recipe_assoc); 2157 2158 return status; 2159 } 2160 2161 /** 2162 * ice_init_chk_recipe_reuse_support - check if recipe reuse is supported 2163 * @hw: pointer to the hardware structure 2164 */ 2165 void ice_init_chk_recipe_reuse_support(struct ice_hw *hw) 2166 { 2167 struct ice_nvm_info *nvm = &hw->flash.nvm; 2168 2169 hw->recp_reuse = (nvm->major == 0x4 && nvm->minor >= 0x30) || 2170 nvm->major > 0x4; 2171 } 2172 2173 /** 2174 * ice_alloc_recipe - add recipe resource 2175 * @hw: pointer to the hardware structure 2176 * @rid: recipe ID returned as response to AQ call 2177 */ 2178 int ice_alloc_recipe(struct ice_hw *hw, u16 *rid) 2179 { 2180 DEFINE_RAW_FLEX(struct ice_aqc_alloc_free_res_elem, sw_buf, elem, 1); 2181 u16 buf_len = __struct_size(sw_buf); 2182 u16 res_type; 2183 int status; 2184 2185 sw_buf->num_elems = cpu_to_le16(1); 2186 res_type = FIELD_PREP(ICE_AQC_RES_TYPE_M, ICE_AQC_RES_TYPE_RECIPE); 2187 if (hw->recp_reuse) 2188 res_type |= ICE_AQC_RES_TYPE_FLAG_SUBSCRIBE_SHARED; 2189 else 2190 res_type |= ICE_AQC_RES_TYPE_FLAG_SHARED; 2191 sw_buf->res_type = cpu_to_le16(res_type); 2192 status = ice_aq_alloc_free_res(hw, sw_buf, buf_len, 2193 ice_aqc_opc_alloc_res); 2194 if (!status) { 2195 *rid = le16_to_cpu(sw_buf->elem[0].e.sw_resp); 2196 hw->switch_info->recp_cnt++; 2197 } 2198 2199 return status; 2200 } 2201 2202 /** 2203 * ice_free_recipe_res - free recipe resource 2204 * @hw: pointer to the hardware structure 2205 * @rid: recipe ID to free 2206 * 2207 * Return: 0 on success, and others on error 2208 */ 2209 static int ice_free_recipe_res(struct ice_hw *hw, u16 rid) 2210 { 2211 int status; 2212 2213 status = ice_free_hw_res(hw, ICE_AQC_RES_TYPE_RECIPE, 1, &rid); 2214 if (!status) 2215 hw->switch_info->recp_cnt--; 2216 2217 return status; 2218 } 2219 2220 /** 2221 * ice_release_recipe_res - disassociate and free recipe resource 2222 * @hw: pointer to the hardware structure 2223 * @recp: the recipe struct resource to unassociate and free 2224 * 2225 * Return: 0 on success, and others on error 2226 */ 2227 static int ice_release_recipe_res(struct ice_hw *hw, 2228 struct ice_sw_recipe *recp) 2229 { 2230 DECLARE_BITMAP(r_bitmap, ICE_MAX_NUM_RECIPES); 2231 struct ice_switch_info *sw = hw->switch_info; 2232 u64 recp_assoc; 2233 u32 rid, prof; 2234 int status; 2235 2236 for_each_set_bit(rid, recp->r_bitmap, ICE_MAX_NUM_RECIPES) { 2237 for_each_set_bit(prof, recipe_to_profile[rid], 2238 ICE_MAX_NUM_PROFILES) { 2239 status = ice_aq_get_recipe_to_profile(hw, prof, 2240 &recp_assoc, 2241 NULL); 2242 if (status) 2243 return status; 2244 2245 bitmap_from_arr64(r_bitmap, &recp_assoc, 2246 ICE_MAX_NUM_RECIPES); 2247 bitmap_andnot(r_bitmap, r_bitmap, recp->r_bitmap, 2248 ICE_MAX_NUM_RECIPES); 2249 bitmap_to_arr64(&recp_assoc, r_bitmap, 2250 ICE_MAX_NUM_RECIPES); 2251 ice_aq_map_recipe_to_profile(hw, prof, 2252 recp_assoc, NULL); 2253 2254 clear_bit(rid, profile_to_recipe[prof]); 2255 clear_bit(prof, recipe_to_profile[rid]); 2256 } 2257 2258 status = ice_free_recipe_res(hw, rid); 2259 if (status) 2260 return status; 2261 2262 sw->recp_list[rid].recp_created = false; 2263 sw->recp_list[rid].adv_rule = false; 2264 memset(&sw->recp_list[rid].lkup_exts, 0, 2265 sizeof(sw->recp_list[rid].lkup_exts)); 2266 clear_bit(rid, recp->r_bitmap); 2267 } 2268 2269 return 0; 2270 } 2271 2272 /** 2273 * ice_get_recp_to_prof_map - updates recipe to profile mapping 2274 * @hw: pointer to hardware structure 2275 * 2276 * This function is used to populate recipe_to_profile matrix where index to 2277 * this array is the recipe ID and the element is the mapping of which profiles 2278 * is this recipe mapped to. 2279 */ 2280 static void ice_get_recp_to_prof_map(struct ice_hw *hw) 2281 { 2282 DECLARE_BITMAP(r_bitmap, ICE_MAX_NUM_RECIPES); 2283 u64 recp_assoc; 2284 u16 i; 2285 2286 for (i = 0; i < hw->switch_info->max_used_prof_index + 1; i++) { 2287 u16 j; 2288 2289 bitmap_zero(profile_to_recipe[i], ICE_MAX_NUM_RECIPES); 2290 bitmap_zero(r_bitmap, ICE_MAX_NUM_RECIPES); 2291 if (ice_aq_get_recipe_to_profile(hw, i, &recp_assoc, NULL)) 2292 continue; 2293 bitmap_from_arr64(r_bitmap, &recp_assoc, ICE_MAX_NUM_RECIPES); 2294 bitmap_copy(profile_to_recipe[i], r_bitmap, 2295 ICE_MAX_NUM_RECIPES); 2296 for_each_set_bit(j, r_bitmap, ICE_MAX_NUM_RECIPES) 2297 set_bit(i, recipe_to_profile[j]); 2298 } 2299 } 2300 2301 /** 2302 * ice_get_recp_frm_fw - update SW bookkeeping from FW recipe entries 2303 * @hw: pointer to hardware structure 2304 * @recps: struct that we need to populate 2305 * @rid: recipe ID that we are populating 2306 * @refresh_required: true if we should get recipe to profile mapping from FW 2307 * @is_add: flag of adding recipe 2308 * 2309 * This function is used to populate all the necessary entries into our 2310 * bookkeeping so that we have a current list of all the recipes that are 2311 * programmed in the firmware. 2312 */ 2313 static int 2314 ice_get_recp_frm_fw(struct ice_hw *hw, struct ice_sw_recipe *recps, u8 rid, 2315 bool *refresh_required, bool is_add) 2316 { 2317 DECLARE_BITMAP(result_bm, ICE_MAX_FV_WORDS); 2318 struct ice_aqc_recipe_data_elem *tmp; 2319 u16 num_recps = ICE_MAX_NUM_RECIPES; 2320 struct ice_prot_lkup_ext *lkup_exts; 2321 u8 fv_word_idx = 0; 2322 u16 sub_recps; 2323 int status; 2324 2325 bitmap_zero(result_bm, ICE_MAX_FV_WORDS); 2326 2327 /* we need a buffer big enough to accommodate all the recipes */ 2328 tmp = kcalloc(ICE_MAX_NUM_RECIPES, sizeof(*tmp), GFP_KERNEL); 2329 if (!tmp) 2330 return -ENOMEM; 2331 2332 tmp[0].recipe_indx = rid; 2333 status = ice_aq_get_recipe(hw, tmp, &num_recps, rid, NULL); 2334 /* non-zero status meaning recipe doesn't exist */ 2335 if (status) 2336 goto err_unroll; 2337 2338 /* Get recipe to profile map so that we can get the fv from lkups that 2339 * we read for a recipe from FW. Since we want to minimize the number of 2340 * times we make this FW call, just make one call and cache the copy 2341 * until a new recipe is added. This operation is only required the 2342 * first time to get the changes from FW. Then to search existing 2343 * entries we don't need to update the cache again until another recipe 2344 * gets added. 2345 */ 2346 if (*refresh_required) { 2347 ice_get_recp_to_prof_map(hw); 2348 *refresh_required = false; 2349 } 2350 2351 /* Start populating all the entries for recps[rid] based on lkups from 2352 * firmware. Note that we are only creating the root recipe in our 2353 * database. 2354 */ 2355 lkup_exts = &recps[rid].lkup_exts; 2356 2357 for (sub_recps = 0; sub_recps < num_recps; sub_recps++) { 2358 struct ice_aqc_recipe_data_elem root_bufs = tmp[sub_recps]; 2359 u8 i, prof, idx, prot = 0; 2360 bool is_root; 2361 u16 off = 0; 2362 2363 idx = root_bufs.recipe_indx; 2364 is_root = root_bufs.content.rid & ICE_AQ_RECIPE_ID_IS_ROOT; 2365 2366 /* Mark all result indices in this chain */ 2367 if (root_bufs.content.result_indx & ICE_AQ_RECIPE_RESULT_EN) 2368 set_bit(root_bufs.content.result_indx & ~ICE_AQ_RECIPE_RESULT_EN, 2369 result_bm); 2370 2371 /* get the first profile that is associated with rid */ 2372 prof = find_first_bit(recipe_to_profile[idx], 2373 ICE_MAX_NUM_PROFILES); 2374 for (i = 0; i < ICE_NUM_WORDS_RECIPE; i++) { 2375 u8 lkup_indx = root_bufs.content.lkup_indx[i]; 2376 u16 lkup_mask = le16_to_cpu(root_bufs.content.mask[i]); 2377 2378 /* If the recipe is a chained recipe then all its 2379 * child recipe's result will have a result index. 2380 * To fill fv_words we should not use those result 2381 * index, we only need the protocol ids and offsets. 2382 * We will skip all the fv_idx which stores result 2383 * index in them. We also need to skip any fv_idx which 2384 * has ICE_AQ_RECIPE_LKUP_IGNORE or 0 since it isn't a 2385 * valid offset value. 2386 */ 2387 if (!lkup_indx || 2388 (lkup_indx & ICE_AQ_RECIPE_LKUP_IGNORE) || 2389 test_bit(lkup_indx, 2390 hw->switch_info->prof_res_bm[prof])) 2391 continue; 2392 2393 ice_find_prot_off(hw, ICE_BLK_SW, prof, lkup_indx, 2394 &prot, &off); 2395 lkup_exts->fv_words[fv_word_idx].prot_id = prot; 2396 lkup_exts->fv_words[fv_word_idx].off = off; 2397 lkup_exts->field_mask[fv_word_idx] = lkup_mask; 2398 fv_word_idx++; 2399 } 2400 2401 /* Propagate some data to the recipe database */ 2402 recps[idx].priority = root_bufs.content.act_ctrl_fwd_priority; 2403 recps[idx].need_pass_l2 = !!(root_bufs.content.act_ctrl & 2404 ICE_AQ_RECIPE_ACT_NEED_PASS_L2); 2405 recps[idx].allow_pass_l2 = !!(root_bufs.content.act_ctrl & 2406 ICE_AQ_RECIPE_ACT_ALLOW_PASS_L2); 2407 bitmap_zero(recps[idx].res_idxs, ICE_MAX_FV_WORDS); 2408 if (root_bufs.content.result_indx & ICE_AQ_RECIPE_RESULT_EN) { 2409 set_bit(root_bufs.content.result_indx & 2410 ~ICE_AQ_RECIPE_RESULT_EN, recps[idx].res_idxs); 2411 } 2412 2413 if (!is_root) { 2414 if (hw->recp_reuse && is_add) 2415 recps[idx].recp_created = true; 2416 2417 continue; 2418 } 2419 2420 /* Only do the following for root recipes entries */ 2421 memcpy(recps[idx].r_bitmap, root_bufs.recipe_bitmap, 2422 sizeof(recps[idx].r_bitmap)); 2423 recps[idx].root_rid = root_bufs.content.rid & 2424 ~ICE_AQ_RECIPE_ID_IS_ROOT; 2425 recps[idx].priority = root_bufs.content.act_ctrl_fwd_priority; 2426 } 2427 2428 /* Complete initialization of the root recipe entry */ 2429 lkup_exts->n_val_words = fv_word_idx; 2430 2431 /* Copy result indexes */ 2432 bitmap_copy(recps[rid].res_idxs, result_bm, ICE_MAX_FV_WORDS); 2433 if (is_add) 2434 recps[rid].recp_created = true; 2435 2436 err_unroll: 2437 kfree(tmp); 2438 return status; 2439 } 2440 2441 /* ice_init_port_info - Initialize port_info with switch configuration data 2442 * @pi: pointer to port_info 2443 * @vsi_port_num: VSI number or port number 2444 * @type: Type of switch element (port or VSI) 2445 * @swid: switch ID of the switch the element is attached to 2446 * @pf_vf_num: PF or VF number 2447 * @is_vf: true if the element is a VF, false otherwise 2448 */ 2449 static void 2450 ice_init_port_info(struct ice_port_info *pi, u16 vsi_port_num, u8 type, 2451 u16 swid, u16 pf_vf_num, bool is_vf) 2452 { 2453 switch (type) { 2454 case ICE_AQC_GET_SW_CONF_RESP_PHYS_PORT: 2455 pi->lport = (u8)(vsi_port_num & ICE_LPORT_MASK); 2456 pi->sw_id = swid; 2457 pi->pf_vf_num = pf_vf_num; 2458 pi->is_vf = is_vf; 2459 break; 2460 default: 2461 ice_debug(pi->hw, ICE_DBG_SW, "incorrect VSI/port type received\n"); 2462 break; 2463 } 2464 } 2465 2466 /* ice_get_initial_sw_cfg - Get initial port and default VSI data 2467 * @hw: pointer to the hardware structure 2468 */ 2469 int ice_get_initial_sw_cfg(struct ice_hw *hw) 2470 { 2471 struct ice_aqc_get_sw_cfg_resp_elem *rbuf; 2472 u16 req_desc = 0; 2473 u16 num_elems; 2474 int status; 2475 u16 i; 2476 2477 rbuf = kzalloc(ICE_SW_CFG_MAX_BUF_LEN, GFP_KERNEL); 2478 if (!rbuf) 2479 return -ENOMEM; 2480 2481 /* Multiple calls to ice_aq_get_sw_cfg may be required 2482 * to get all the switch configuration information. The need 2483 * for additional calls is indicated by ice_aq_get_sw_cfg 2484 * writing a non-zero value in req_desc 2485 */ 2486 do { 2487 struct ice_aqc_get_sw_cfg_resp_elem *ele; 2488 2489 status = ice_aq_get_sw_cfg(hw, rbuf, ICE_SW_CFG_MAX_BUF_LEN, 2490 &req_desc, &num_elems, NULL); 2491 2492 if (status) 2493 break; 2494 2495 for (i = 0, ele = rbuf; i < num_elems; i++, ele++) { 2496 u16 pf_vf_num, swid, vsi_port_num; 2497 bool is_vf = false; 2498 u8 res_type; 2499 2500 vsi_port_num = le16_to_cpu(ele->vsi_port_num) & 2501 ICE_AQC_GET_SW_CONF_RESP_VSI_PORT_NUM_M; 2502 2503 pf_vf_num = le16_to_cpu(ele->pf_vf_num) & 2504 ICE_AQC_GET_SW_CONF_RESP_FUNC_NUM_M; 2505 2506 swid = le16_to_cpu(ele->swid); 2507 2508 if (le16_to_cpu(ele->pf_vf_num) & 2509 ICE_AQC_GET_SW_CONF_RESP_IS_VF) 2510 is_vf = true; 2511 2512 res_type = (u8)(le16_to_cpu(ele->vsi_port_num) >> 2513 ICE_AQC_GET_SW_CONF_RESP_TYPE_S); 2514 2515 if (res_type == ICE_AQC_GET_SW_CONF_RESP_VSI) { 2516 /* FW VSI is not needed. Just continue. */ 2517 continue; 2518 } 2519 2520 ice_init_port_info(hw->port_info, vsi_port_num, 2521 res_type, swid, pf_vf_num, is_vf); 2522 } 2523 } while (req_desc && !status); 2524 2525 kfree(rbuf); 2526 return status; 2527 } 2528 2529 /** 2530 * ice_fill_sw_info - Helper function to populate lb_en and lan_en 2531 * @hw: pointer to the hardware structure 2532 * @fi: filter info structure to fill/update 2533 * 2534 * This helper function populates the lb_en and lan_en elements of the provided 2535 * ice_fltr_info struct using the switch's type and characteristics of the 2536 * switch rule being configured. 2537 */ 2538 static void ice_fill_sw_info(struct ice_hw *hw, struct ice_fltr_info *fi) 2539 { 2540 fi->lb_en = false; 2541 fi->lan_en = false; 2542 if ((fi->flag & ICE_FLTR_TX) && 2543 (fi->fltr_act == ICE_FWD_TO_VSI || 2544 fi->fltr_act == ICE_FWD_TO_VSI_LIST || 2545 fi->fltr_act == ICE_FWD_TO_Q || 2546 fi->fltr_act == ICE_FWD_TO_QGRP)) { 2547 /* Setting LB for prune actions will result in replicated 2548 * packets to the internal switch that will be dropped. 2549 */ 2550 if (fi->lkup_type != ICE_SW_LKUP_VLAN) 2551 fi->lb_en = true; 2552 2553 /* Set lan_en to TRUE if 2554 * 1. The switch is a VEB AND 2555 * 2 2556 * 2.1 The lookup is a directional lookup like ethertype, 2557 * promiscuous, ethertype-MAC, promiscuous-VLAN 2558 * and default-port OR 2559 * 2.2 The lookup is VLAN, OR 2560 * 2.3 The lookup is MAC with mcast or bcast addr for MAC, OR 2561 * 2.4 The lookup is MAC_VLAN with mcast or bcast addr for MAC. 2562 * 2563 * OR 2564 * 2565 * The switch is a VEPA. 2566 * 2567 * In all other cases, the LAN enable has to be set to false. 2568 */ 2569 if (hw->evb_veb) { 2570 if (fi->lkup_type == ICE_SW_LKUP_ETHERTYPE || 2571 fi->lkup_type == ICE_SW_LKUP_PROMISC || 2572 fi->lkup_type == ICE_SW_LKUP_ETHERTYPE_MAC || 2573 fi->lkup_type == ICE_SW_LKUP_PROMISC_VLAN || 2574 fi->lkup_type == ICE_SW_LKUP_DFLT || 2575 fi->lkup_type == ICE_SW_LKUP_VLAN || 2576 (fi->lkup_type == ICE_SW_LKUP_MAC && 2577 !is_unicast_ether_addr(fi->l_data.mac.mac_addr)) || 2578 (fi->lkup_type == ICE_SW_LKUP_MAC_VLAN && 2579 !is_unicast_ether_addr(fi->l_data.mac.mac_addr))) 2580 fi->lan_en = true; 2581 } else { 2582 fi->lan_en = true; 2583 } 2584 } 2585 2586 if (fi->flag & ICE_FLTR_TX_ONLY) 2587 fi->lan_en = false; 2588 } 2589 2590 /** 2591 * ice_fill_eth_hdr - helper to copy dummy_eth_hdr into supplied buffer 2592 * @eth_hdr: pointer to buffer to populate 2593 */ 2594 void ice_fill_eth_hdr(u8 *eth_hdr) 2595 { 2596 memcpy(eth_hdr, dummy_eth_header, DUMMY_ETH_HDR_LEN); 2597 } 2598 2599 /** 2600 * ice_fill_sw_rule - Helper function to fill switch rule structure 2601 * @hw: pointer to the hardware structure 2602 * @f_info: entry containing packet forwarding information 2603 * @s_rule: switch rule structure to be filled in based on mac_entry 2604 * @opc: switch rules population command type - pass in the command opcode 2605 */ 2606 static void 2607 ice_fill_sw_rule(struct ice_hw *hw, struct ice_fltr_info *f_info, 2608 struct ice_sw_rule_lkup_rx_tx *s_rule, 2609 enum ice_adminq_opc opc) 2610 { 2611 u16 vlan_id = ICE_MAX_VLAN_ID + 1; 2612 u16 vlan_tpid = ETH_P_8021Q; 2613 void *daddr = NULL; 2614 u16 eth_hdr_sz; 2615 u8 *eth_hdr; 2616 u32 act = 0; 2617 __be16 *off; 2618 u8 q_rgn; 2619 2620 if (opc == ice_aqc_opc_remove_sw_rules) { 2621 s_rule->act = 0; 2622 s_rule->index = cpu_to_le16(f_info->fltr_rule_id); 2623 s_rule->hdr_len = 0; 2624 return; 2625 } 2626 2627 eth_hdr_sz = sizeof(dummy_eth_header); 2628 eth_hdr = s_rule->hdr_data; 2629 2630 /* initialize the ether header with a dummy header */ 2631 memcpy(eth_hdr, dummy_eth_header, eth_hdr_sz); 2632 ice_fill_sw_info(hw, f_info); 2633 2634 switch (f_info->fltr_act) { 2635 case ICE_FWD_TO_VSI: 2636 act |= FIELD_PREP(ICE_SINGLE_ACT_VSI_ID_M, 2637 f_info->fwd_id.hw_vsi_id); 2638 if (f_info->lkup_type != ICE_SW_LKUP_VLAN) 2639 act |= ICE_SINGLE_ACT_VSI_FORWARDING | 2640 ICE_SINGLE_ACT_VALID_BIT; 2641 break; 2642 case ICE_FWD_TO_VSI_LIST: 2643 act |= ICE_SINGLE_ACT_VSI_LIST; 2644 act |= FIELD_PREP(ICE_SINGLE_ACT_VSI_LIST_ID_M, 2645 f_info->fwd_id.vsi_list_id); 2646 if (f_info->lkup_type != ICE_SW_LKUP_VLAN) 2647 act |= ICE_SINGLE_ACT_VSI_FORWARDING | 2648 ICE_SINGLE_ACT_VALID_BIT; 2649 break; 2650 case ICE_FWD_TO_Q: 2651 act |= ICE_SINGLE_ACT_TO_Q; 2652 act |= FIELD_PREP(ICE_SINGLE_ACT_Q_INDEX_M, 2653 f_info->fwd_id.q_id); 2654 break; 2655 case ICE_DROP_PACKET: 2656 act |= ICE_SINGLE_ACT_VSI_FORWARDING | ICE_SINGLE_ACT_DROP | 2657 ICE_SINGLE_ACT_VALID_BIT; 2658 break; 2659 case ICE_FWD_TO_QGRP: 2660 q_rgn = f_info->qgrp_size > 0 ? 2661 (u8)ilog2(f_info->qgrp_size) : 0; 2662 act |= ICE_SINGLE_ACT_TO_Q; 2663 act |= FIELD_PREP(ICE_SINGLE_ACT_Q_INDEX_M, 2664 f_info->fwd_id.q_id); 2665 act |= FIELD_PREP(ICE_SINGLE_ACT_Q_REGION_M, q_rgn); 2666 break; 2667 default: 2668 return; 2669 } 2670 2671 if (f_info->lb_en) 2672 act |= ICE_SINGLE_ACT_LB_ENABLE; 2673 if (f_info->lan_en) 2674 act |= ICE_SINGLE_ACT_LAN_ENABLE; 2675 2676 switch (f_info->lkup_type) { 2677 case ICE_SW_LKUP_MAC: 2678 daddr = f_info->l_data.mac.mac_addr; 2679 break; 2680 case ICE_SW_LKUP_VLAN: 2681 vlan_id = f_info->l_data.vlan.vlan_id; 2682 if (f_info->l_data.vlan.tpid_valid) 2683 vlan_tpid = f_info->l_data.vlan.tpid; 2684 if (f_info->fltr_act == ICE_FWD_TO_VSI || 2685 f_info->fltr_act == ICE_FWD_TO_VSI_LIST) { 2686 act |= ICE_SINGLE_ACT_PRUNE; 2687 act |= ICE_SINGLE_ACT_EGRESS | ICE_SINGLE_ACT_INGRESS; 2688 } 2689 break; 2690 case ICE_SW_LKUP_ETHERTYPE_MAC: 2691 daddr = f_info->l_data.ethertype_mac.mac_addr; 2692 fallthrough; 2693 case ICE_SW_LKUP_ETHERTYPE: 2694 off = (__force __be16 *)(eth_hdr + ICE_ETH_ETHTYPE_OFFSET); 2695 *off = cpu_to_be16(f_info->l_data.ethertype_mac.ethertype); 2696 break; 2697 case ICE_SW_LKUP_MAC_VLAN: 2698 daddr = f_info->l_data.mac_vlan.mac_addr; 2699 vlan_id = f_info->l_data.mac_vlan.vlan_id; 2700 break; 2701 case ICE_SW_LKUP_PROMISC_VLAN: 2702 vlan_id = f_info->l_data.mac_vlan.vlan_id; 2703 fallthrough; 2704 case ICE_SW_LKUP_PROMISC: 2705 daddr = f_info->l_data.mac_vlan.mac_addr; 2706 break; 2707 default: 2708 break; 2709 } 2710 2711 s_rule->hdr.type = (f_info->flag & ICE_FLTR_RX) ? 2712 cpu_to_le16(ICE_AQC_SW_RULES_T_LKUP_RX) : 2713 cpu_to_le16(ICE_AQC_SW_RULES_T_LKUP_TX); 2714 2715 /* Recipe set depending on lookup type */ 2716 s_rule->recipe_id = cpu_to_le16(f_info->lkup_type); 2717 s_rule->src = cpu_to_le16(f_info->src); 2718 s_rule->act = cpu_to_le32(act); 2719 2720 if (daddr) 2721 ether_addr_copy(eth_hdr + ICE_ETH_DA_OFFSET, daddr); 2722 2723 if (!(vlan_id > ICE_MAX_VLAN_ID)) { 2724 off = (__force __be16 *)(eth_hdr + ICE_ETH_VLAN_TCI_OFFSET); 2725 *off = cpu_to_be16(vlan_id); 2726 off = (__force __be16 *)(eth_hdr + ICE_ETH_ETHTYPE_OFFSET); 2727 *off = cpu_to_be16(vlan_tpid); 2728 } 2729 2730 /* Create the switch rule with the final dummy Ethernet header */ 2731 if (opc != ice_aqc_opc_update_sw_rules) 2732 s_rule->hdr_len = cpu_to_le16(eth_hdr_sz); 2733 } 2734 2735 /** 2736 * ice_add_marker_act 2737 * @hw: pointer to the hardware structure 2738 * @m_ent: the management entry for which sw marker needs to be added 2739 * @sw_marker: sw marker to tag the Rx descriptor with 2740 * @l_id: large action resource ID 2741 * 2742 * Create a large action to hold software marker and update the switch rule 2743 * entry pointed by m_ent with newly created large action 2744 */ 2745 static int 2746 ice_add_marker_act(struct ice_hw *hw, struct ice_fltr_mgmt_list_entry *m_ent, 2747 u16 sw_marker, u16 l_id) 2748 { 2749 struct ice_sw_rule_lkup_rx_tx *rx_tx; 2750 struct ice_sw_rule_lg_act *lg_act; 2751 /* For software marker we need 3 large actions 2752 * 1. FWD action: FWD TO VSI or VSI LIST 2753 * 2. GENERIC VALUE action to hold the profile ID 2754 * 3. GENERIC VALUE action to hold the software marker ID 2755 */ 2756 const u16 num_lg_acts = 3; 2757 u16 lg_act_size; 2758 u16 rules_size; 2759 int status; 2760 u32 act; 2761 u16 id; 2762 2763 if (m_ent->fltr_info.lkup_type != ICE_SW_LKUP_MAC) 2764 return -EINVAL; 2765 2766 /* Create two back-to-back switch rules and submit them to the HW using 2767 * one memory buffer: 2768 * 1. Large Action 2769 * 2. Look up Tx Rx 2770 */ 2771 lg_act_size = (u16)ICE_SW_RULE_LG_ACT_SIZE(lg_act, num_lg_acts); 2772 rules_size = lg_act_size + ICE_SW_RULE_RX_TX_ETH_HDR_SIZE(rx_tx); 2773 lg_act = devm_kzalloc(ice_hw_to_dev(hw), rules_size, GFP_KERNEL); 2774 if (!lg_act) 2775 return -ENOMEM; 2776 2777 rx_tx = (typeof(rx_tx))((u8 *)lg_act + lg_act_size); 2778 2779 /* Fill in the first switch rule i.e. large action */ 2780 lg_act->hdr.type = cpu_to_le16(ICE_AQC_SW_RULES_T_LG_ACT); 2781 lg_act->index = cpu_to_le16(l_id); 2782 lg_act->size = cpu_to_le16(num_lg_acts); 2783 2784 /* First action VSI forwarding or VSI list forwarding depending on how 2785 * many VSIs 2786 */ 2787 id = (m_ent->vsi_count > 1) ? m_ent->fltr_info.fwd_id.vsi_list_id : 2788 m_ent->fltr_info.fwd_id.hw_vsi_id; 2789 2790 act = ICE_LG_ACT_VSI_FORWARDING | ICE_LG_ACT_VALID_BIT; 2791 act |= FIELD_PREP(ICE_LG_ACT_VSI_LIST_ID_M, id); 2792 if (m_ent->vsi_count > 1) 2793 act |= ICE_LG_ACT_VSI_LIST; 2794 lg_act->act[0] = cpu_to_le32(act); 2795 2796 /* Second action descriptor type */ 2797 act = ICE_LG_ACT_GENERIC; 2798 2799 act |= FIELD_PREP(ICE_LG_ACT_GENERIC_VALUE_M, 1); 2800 lg_act->act[1] = cpu_to_le32(act); 2801 2802 act = FIELD_PREP(ICE_LG_ACT_GENERIC_OFFSET_M, 2803 ICE_LG_ACT_GENERIC_OFF_RX_DESC_PROF_IDX); 2804 2805 /* Third action Marker value */ 2806 act |= ICE_LG_ACT_GENERIC; 2807 act |= FIELD_PREP(ICE_LG_ACT_GENERIC_VALUE_M, sw_marker); 2808 2809 lg_act->act[2] = cpu_to_le32(act); 2810 2811 /* call the fill switch rule to fill the lookup Tx Rx structure */ 2812 ice_fill_sw_rule(hw, &m_ent->fltr_info, rx_tx, 2813 ice_aqc_opc_update_sw_rules); 2814 2815 /* Update the action to point to the large action ID */ 2816 act = ICE_SINGLE_ACT_PTR; 2817 act |= FIELD_PREP(ICE_SINGLE_ACT_PTR_VAL_M, l_id); 2818 rx_tx->act = cpu_to_le32(act); 2819 2820 /* Use the filter rule ID of the previously created rule with single 2821 * act. Once the update happens, hardware will treat this as large 2822 * action 2823 */ 2824 rx_tx->index = cpu_to_le16(m_ent->fltr_info.fltr_rule_id); 2825 2826 status = ice_aq_sw_rules(hw, lg_act, rules_size, 2, 2827 ice_aqc_opc_update_sw_rules, NULL); 2828 if (!status) { 2829 m_ent->lg_act_idx = l_id; 2830 m_ent->sw_marker_id = sw_marker; 2831 } 2832 2833 devm_kfree(ice_hw_to_dev(hw), lg_act); 2834 return status; 2835 } 2836 2837 /** 2838 * ice_create_vsi_list_map 2839 * @hw: pointer to the hardware structure 2840 * @vsi_handle_arr: array of VSI handles to set in the VSI mapping 2841 * @num_vsi: number of VSI handles in the array 2842 * @vsi_list_id: VSI list ID generated as part of allocate resource 2843 * 2844 * Helper function to create a new entry of VSI list ID to VSI mapping 2845 * using the given VSI list ID 2846 */ 2847 static struct ice_vsi_list_map_info * 2848 ice_create_vsi_list_map(struct ice_hw *hw, u16 *vsi_handle_arr, u16 num_vsi, 2849 u16 vsi_list_id) 2850 { 2851 struct ice_switch_info *sw = hw->switch_info; 2852 struct ice_vsi_list_map_info *v_map; 2853 int i; 2854 2855 v_map = devm_kzalloc(ice_hw_to_dev(hw), sizeof(*v_map), GFP_KERNEL); 2856 if (!v_map) 2857 return NULL; 2858 2859 v_map->vsi_list_id = vsi_list_id; 2860 v_map->ref_cnt = 1; 2861 for (i = 0; i < num_vsi; i++) 2862 set_bit(vsi_handle_arr[i], v_map->vsi_map); 2863 2864 list_add(&v_map->list_entry, &sw->vsi_list_map_head); 2865 return v_map; 2866 } 2867 2868 /** 2869 * ice_update_vsi_list_rule 2870 * @hw: pointer to the hardware structure 2871 * @vsi_handle_arr: array of VSI handles to form a VSI list 2872 * @num_vsi: number of VSI handles in the array 2873 * @vsi_list_id: VSI list ID generated as part of allocate resource 2874 * @remove: Boolean value to indicate if this is a remove action 2875 * @opc: switch rules population command type - pass in the command opcode 2876 * @lkup_type: lookup type of the filter 2877 * 2878 * Call AQ command to add a new switch rule or update existing switch rule 2879 * using the given VSI list ID 2880 */ 2881 static int 2882 ice_update_vsi_list_rule(struct ice_hw *hw, u16 *vsi_handle_arr, u16 num_vsi, 2883 u16 vsi_list_id, bool remove, enum ice_adminq_opc opc, 2884 enum ice_sw_lkup_type lkup_type) 2885 { 2886 struct ice_sw_rule_vsi_list *s_rule; 2887 u16 s_rule_size; 2888 u16 rule_type; 2889 int status; 2890 int i; 2891 2892 if (!num_vsi) 2893 return -EINVAL; 2894 2895 if (lkup_type == ICE_SW_LKUP_MAC || 2896 lkup_type == ICE_SW_LKUP_MAC_VLAN || 2897 lkup_type == ICE_SW_LKUP_ETHERTYPE || 2898 lkup_type == ICE_SW_LKUP_ETHERTYPE_MAC || 2899 lkup_type == ICE_SW_LKUP_PROMISC || 2900 lkup_type == ICE_SW_LKUP_PROMISC_VLAN || 2901 lkup_type == ICE_SW_LKUP_DFLT || 2902 lkup_type == ICE_SW_LKUP_LAST) 2903 rule_type = remove ? ICE_AQC_SW_RULES_T_VSI_LIST_CLEAR : 2904 ICE_AQC_SW_RULES_T_VSI_LIST_SET; 2905 else if (lkup_type == ICE_SW_LKUP_VLAN) 2906 rule_type = remove ? ICE_AQC_SW_RULES_T_PRUNE_LIST_CLEAR : 2907 ICE_AQC_SW_RULES_T_PRUNE_LIST_SET; 2908 else 2909 return -EINVAL; 2910 2911 s_rule_size = (u16)ICE_SW_RULE_VSI_LIST_SIZE(s_rule, num_vsi); 2912 s_rule = devm_kzalloc(ice_hw_to_dev(hw), s_rule_size, GFP_KERNEL); 2913 if (!s_rule) 2914 return -ENOMEM; 2915 for (i = 0; i < num_vsi; i++) { 2916 if (!ice_is_vsi_valid(hw, vsi_handle_arr[i])) { 2917 status = -EINVAL; 2918 goto exit; 2919 } 2920 /* AQ call requires hw_vsi_id(s) */ 2921 s_rule->vsi[i] = 2922 cpu_to_le16(ice_get_hw_vsi_num(hw, vsi_handle_arr[i])); 2923 } 2924 2925 s_rule->hdr.type = cpu_to_le16(rule_type); 2926 s_rule->number_vsi = cpu_to_le16(num_vsi); 2927 s_rule->index = cpu_to_le16(vsi_list_id); 2928 2929 status = ice_aq_sw_rules(hw, s_rule, s_rule_size, 1, opc, NULL); 2930 2931 exit: 2932 devm_kfree(ice_hw_to_dev(hw), s_rule); 2933 return status; 2934 } 2935 2936 /** 2937 * ice_create_vsi_list_rule - Creates and populates a VSI list rule 2938 * @hw: pointer to the HW struct 2939 * @vsi_handle_arr: array of VSI handles to form a VSI list 2940 * @num_vsi: number of VSI handles in the array 2941 * @vsi_list_id: stores the ID of the VSI list to be created 2942 * @lkup_type: switch rule filter's lookup type 2943 */ 2944 static int 2945 ice_create_vsi_list_rule(struct ice_hw *hw, u16 *vsi_handle_arr, u16 num_vsi, 2946 u16 *vsi_list_id, enum ice_sw_lkup_type lkup_type) 2947 { 2948 int status; 2949 2950 status = ice_aq_alloc_free_vsi_list(hw, vsi_list_id, lkup_type, 2951 ice_aqc_opc_alloc_res); 2952 if (status) 2953 return status; 2954 2955 /* Update the newly created VSI list to include the specified VSIs */ 2956 return ice_update_vsi_list_rule(hw, vsi_handle_arr, num_vsi, 2957 *vsi_list_id, false, 2958 ice_aqc_opc_add_sw_rules, lkup_type); 2959 } 2960 2961 /** 2962 * ice_create_pkt_fwd_rule 2963 * @hw: pointer to the hardware structure 2964 * @f_entry: entry containing packet forwarding information 2965 * 2966 * Create switch rule with given filter information and add an entry 2967 * to the corresponding filter management list to track this switch rule 2968 * and VSI mapping 2969 */ 2970 static int 2971 ice_create_pkt_fwd_rule(struct ice_hw *hw, 2972 struct ice_fltr_list_entry *f_entry) 2973 { 2974 struct ice_fltr_mgmt_list_entry *fm_entry; 2975 struct ice_sw_rule_lkup_rx_tx *s_rule; 2976 enum ice_sw_lkup_type l_type; 2977 struct ice_sw_recipe *recp; 2978 int status; 2979 2980 s_rule = devm_kzalloc(ice_hw_to_dev(hw), 2981 ICE_SW_RULE_RX_TX_ETH_HDR_SIZE(s_rule), 2982 GFP_KERNEL); 2983 if (!s_rule) 2984 return -ENOMEM; 2985 fm_entry = devm_kzalloc(ice_hw_to_dev(hw), sizeof(*fm_entry), 2986 GFP_KERNEL); 2987 if (!fm_entry) { 2988 status = -ENOMEM; 2989 goto ice_create_pkt_fwd_rule_exit; 2990 } 2991 2992 fm_entry->fltr_info = f_entry->fltr_info; 2993 2994 /* Initialize all the fields for the management entry */ 2995 fm_entry->vsi_count = 1; 2996 fm_entry->lg_act_idx = ICE_INVAL_LG_ACT_INDEX; 2997 fm_entry->sw_marker_id = ICE_INVAL_SW_MARKER_ID; 2998 fm_entry->counter_index = ICE_INVAL_COUNTER_ID; 2999 3000 ice_fill_sw_rule(hw, &fm_entry->fltr_info, s_rule, 3001 ice_aqc_opc_add_sw_rules); 3002 3003 status = ice_aq_sw_rules(hw, s_rule, 3004 ICE_SW_RULE_RX_TX_ETH_HDR_SIZE(s_rule), 1, 3005 ice_aqc_opc_add_sw_rules, NULL); 3006 if (status) { 3007 devm_kfree(ice_hw_to_dev(hw), fm_entry); 3008 goto ice_create_pkt_fwd_rule_exit; 3009 } 3010 3011 f_entry->fltr_info.fltr_rule_id = le16_to_cpu(s_rule->index); 3012 fm_entry->fltr_info.fltr_rule_id = le16_to_cpu(s_rule->index); 3013 3014 /* The book keeping entries will get removed when base driver 3015 * calls remove filter AQ command 3016 */ 3017 l_type = fm_entry->fltr_info.lkup_type; 3018 recp = &hw->switch_info->recp_list[l_type]; 3019 list_add(&fm_entry->list_entry, &recp->filt_rules); 3020 3021 ice_create_pkt_fwd_rule_exit: 3022 devm_kfree(ice_hw_to_dev(hw), s_rule); 3023 return status; 3024 } 3025 3026 /** 3027 * ice_update_pkt_fwd_rule 3028 * @hw: pointer to the hardware structure 3029 * @f_info: filter information for switch rule 3030 * 3031 * Call AQ command to update a previously created switch rule with a 3032 * VSI list ID 3033 */ 3034 static int 3035 ice_update_pkt_fwd_rule(struct ice_hw *hw, struct ice_fltr_info *f_info) 3036 { 3037 struct ice_sw_rule_lkup_rx_tx *s_rule; 3038 int status; 3039 3040 s_rule = devm_kzalloc(ice_hw_to_dev(hw), 3041 ICE_SW_RULE_RX_TX_ETH_HDR_SIZE(s_rule), 3042 GFP_KERNEL); 3043 if (!s_rule) 3044 return -ENOMEM; 3045 3046 ice_fill_sw_rule(hw, f_info, s_rule, ice_aqc_opc_update_sw_rules); 3047 3048 s_rule->index = cpu_to_le16(f_info->fltr_rule_id); 3049 3050 /* Update switch rule with new rule set to forward VSI list */ 3051 status = ice_aq_sw_rules(hw, s_rule, 3052 ICE_SW_RULE_RX_TX_ETH_HDR_SIZE(s_rule), 1, 3053 ice_aqc_opc_update_sw_rules, NULL); 3054 3055 devm_kfree(ice_hw_to_dev(hw), s_rule); 3056 return status; 3057 } 3058 3059 /** 3060 * ice_update_sw_rule_bridge_mode 3061 * @hw: pointer to the HW struct 3062 * 3063 * Updates unicast switch filter rules based on VEB/VEPA mode 3064 */ 3065 int ice_update_sw_rule_bridge_mode(struct ice_hw *hw) 3066 { 3067 struct ice_switch_info *sw = hw->switch_info; 3068 struct ice_fltr_mgmt_list_entry *fm_entry; 3069 struct list_head *rule_head; 3070 struct mutex *rule_lock; /* Lock to protect filter rule list */ 3071 int status = 0; 3072 3073 rule_lock = &sw->recp_list[ICE_SW_LKUP_MAC].filt_rule_lock; 3074 rule_head = &sw->recp_list[ICE_SW_LKUP_MAC].filt_rules; 3075 3076 mutex_lock(rule_lock); 3077 list_for_each_entry(fm_entry, rule_head, list_entry) { 3078 struct ice_fltr_info *fi = &fm_entry->fltr_info; 3079 u8 *addr = fi->l_data.mac.mac_addr; 3080 3081 /* Update unicast Tx rules to reflect the selected 3082 * VEB/VEPA mode 3083 */ 3084 if ((fi->flag & ICE_FLTR_TX) && is_unicast_ether_addr(addr) && 3085 (fi->fltr_act == ICE_FWD_TO_VSI || 3086 fi->fltr_act == ICE_FWD_TO_VSI_LIST || 3087 fi->fltr_act == ICE_FWD_TO_Q || 3088 fi->fltr_act == ICE_FWD_TO_QGRP)) { 3089 status = ice_update_pkt_fwd_rule(hw, fi); 3090 if (status) 3091 break; 3092 } 3093 } 3094 3095 mutex_unlock(rule_lock); 3096 3097 return status; 3098 } 3099 3100 /** 3101 * ice_add_update_vsi_list 3102 * @hw: pointer to the hardware structure 3103 * @m_entry: pointer to current filter management list entry 3104 * @cur_fltr: filter information from the book keeping entry 3105 * @new_fltr: filter information with the new VSI to be added 3106 * 3107 * Call AQ command to add or update previously created VSI list with new VSI. 3108 * 3109 * Helper function to do book keeping associated with adding filter information 3110 * The algorithm to do the book keeping is described below : 3111 * When a VSI needs to subscribe to a given filter (MAC/VLAN/Ethtype etc.) 3112 * if only one VSI has been added till now 3113 * Allocate a new VSI list and add two VSIs 3114 * to this list using switch rule command 3115 * Update the previously created switch rule with the 3116 * newly created VSI list ID 3117 * if a VSI list was previously created 3118 * Add the new VSI to the previously created VSI list set 3119 * using the update switch rule command 3120 */ 3121 static int 3122 ice_add_update_vsi_list(struct ice_hw *hw, 3123 struct ice_fltr_mgmt_list_entry *m_entry, 3124 struct ice_fltr_info *cur_fltr, 3125 struct ice_fltr_info *new_fltr) 3126 { 3127 u16 vsi_list_id = 0; 3128 int status = 0; 3129 3130 if ((cur_fltr->fltr_act == ICE_FWD_TO_Q || 3131 cur_fltr->fltr_act == ICE_FWD_TO_QGRP)) 3132 return -EOPNOTSUPP; 3133 3134 if ((new_fltr->fltr_act == ICE_FWD_TO_Q || 3135 new_fltr->fltr_act == ICE_FWD_TO_QGRP) && 3136 (cur_fltr->fltr_act == ICE_FWD_TO_VSI || 3137 cur_fltr->fltr_act == ICE_FWD_TO_VSI_LIST)) 3138 return -EOPNOTSUPP; 3139 3140 if (m_entry->vsi_count < 2 && !m_entry->vsi_list_info) { 3141 /* Only one entry existed in the mapping and it was not already 3142 * a part of a VSI list. So, create a VSI list with the old and 3143 * new VSIs. 3144 */ 3145 struct ice_fltr_info tmp_fltr; 3146 u16 vsi_handle_arr[2]; 3147 3148 /* A rule already exists with the new VSI being added */ 3149 if (cur_fltr->fwd_id.hw_vsi_id == new_fltr->fwd_id.hw_vsi_id) 3150 return -EEXIST; 3151 3152 vsi_handle_arr[0] = cur_fltr->vsi_handle; 3153 vsi_handle_arr[1] = new_fltr->vsi_handle; 3154 status = ice_create_vsi_list_rule(hw, &vsi_handle_arr[0], 2, 3155 &vsi_list_id, 3156 new_fltr->lkup_type); 3157 if (status) 3158 return status; 3159 3160 tmp_fltr = *new_fltr; 3161 tmp_fltr.fltr_rule_id = cur_fltr->fltr_rule_id; 3162 tmp_fltr.fltr_act = ICE_FWD_TO_VSI_LIST; 3163 tmp_fltr.fwd_id.vsi_list_id = vsi_list_id; 3164 /* Update the previous switch rule of "MAC forward to VSI" to 3165 * "MAC fwd to VSI list" 3166 */ 3167 status = ice_update_pkt_fwd_rule(hw, &tmp_fltr); 3168 if (status) 3169 return status; 3170 3171 cur_fltr->fwd_id.vsi_list_id = vsi_list_id; 3172 cur_fltr->fltr_act = ICE_FWD_TO_VSI_LIST; 3173 m_entry->vsi_list_info = 3174 ice_create_vsi_list_map(hw, &vsi_handle_arr[0], 2, 3175 vsi_list_id); 3176 3177 if (!m_entry->vsi_list_info) 3178 return -ENOMEM; 3179 3180 /* If this entry was large action then the large action needs 3181 * to be updated to point to FWD to VSI list 3182 */ 3183 if (m_entry->sw_marker_id != ICE_INVAL_SW_MARKER_ID) 3184 status = 3185 ice_add_marker_act(hw, m_entry, 3186 m_entry->sw_marker_id, 3187 m_entry->lg_act_idx); 3188 } else { 3189 u16 vsi_handle = new_fltr->vsi_handle; 3190 enum ice_adminq_opc opcode; 3191 3192 if (!m_entry->vsi_list_info) 3193 return -EIO; 3194 3195 /* A rule already exists with the new VSI being added */ 3196 if (test_bit(vsi_handle, m_entry->vsi_list_info->vsi_map)) 3197 return -EEXIST; 3198 3199 /* Update the previously created VSI list set with 3200 * the new VSI ID passed in 3201 */ 3202 vsi_list_id = cur_fltr->fwd_id.vsi_list_id; 3203 opcode = ice_aqc_opc_update_sw_rules; 3204 3205 status = ice_update_vsi_list_rule(hw, &vsi_handle, 1, 3206 vsi_list_id, false, opcode, 3207 new_fltr->lkup_type); 3208 /* update VSI list mapping info with new VSI ID */ 3209 if (!status) 3210 set_bit(vsi_handle, m_entry->vsi_list_info->vsi_map); 3211 } 3212 if (!status) 3213 m_entry->vsi_count++; 3214 return status; 3215 } 3216 3217 /** 3218 * ice_find_rule_entry - Search a rule entry 3219 * @hw: pointer to the hardware structure 3220 * @recp_id: lookup type for which the specified rule needs to be searched 3221 * @f_info: rule information 3222 * 3223 * Helper function to search for a given rule entry 3224 * Returns pointer to entry storing the rule if found 3225 */ 3226 static struct ice_fltr_mgmt_list_entry * 3227 ice_find_rule_entry(struct ice_hw *hw, u8 recp_id, struct ice_fltr_info *f_info) 3228 { 3229 struct ice_fltr_mgmt_list_entry *list_itr, *ret = NULL; 3230 struct ice_switch_info *sw = hw->switch_info; 3231 struct list_head *list_head; 3232 3233 list_head = &sw->recp_list[recp_id].filt_rules; 3234 list_for_each_entry(list_itr, list_head, list_entry) { 3235 if (!memcmp(&f_info->l_data, &list_itr->fltr_info.l_data, 3236 sizeof(f_info->l_data)) && 3237 f_info->flag == list_itr->fltr_info.flag) { 3238 ret = list_itr; 3239 break; 3240 } 3241 } 3242 return ret; 3243 } 3244 3245 /** 3246 * ice_find_vsi_list_entry - Search VSI list map with VSI count 1 3247 * @hw: pointer to the hardware structure 3248 * @recp_id: lookup type for which VSI lists needs to be searched 3249 * @vsi_handle: VSI handle to be found in VSI list 3250 * @vsi_list_id: VSI list ID found containing vsi_handle 3251 * 3252 * Helper function to search a VSI list with single entry containing given VSI 3253 * handle element. This can be extended further to search VSI list with more 3254 * than 1 vsi_count. Returns pointer to VSI list entry if found. 3255 */ 3256 struct ice_vsi_list_map_info * 3257 ice_find_vsi_list_entry(struct ice_hw *hw, u8 recp_id, u16 vsi_handle, 3258 u16 *vsi_list_id) 3259 { 3260 struct ice_vsi_list_map_info *map_info = NULL; 3261 struct ice_switch_info *sw = hw->switch_info; 3262 struct ice_fltr_mgmt_list_entry *list_itr; 3263 struct list_head *list_head; 3264 3265 list_head = &sw->recp_list[recp_id].filt_rules; 3266 list_for_each_entry(list_itr, list_head, list_entry) { 3267 if (list_itr->vsi_count == 1 && list_itr->vsi_list_info) { 3268 map_info = list_itr->vsi_list_info; 3269 if (test_bit(vsi_handle, map_info->vsi_map)) { 3270 *vsi_list_id = map_info->vsi_list_id; 3271 return map_info; 3272 } 3273 } 3274 } 3275 return NULL; 3276 } 3277 3278 /** 3279 * ice_add_rule_internal - add rule for a given lookup type 3280 * @hw: pointer to the hardware structure 3281 * @recp_id: lookup type (recipe ID) for which rule has to be added 3282 * @f_entry: structure containing MAC forwarding information 3283 * 3284 * Adds or updates the rule lists for a given recipe 3285 */ 3286 static int 3287 ice_add_rule_internal(struct ice_hw *hw, u8 recp_id, 3288 struct ice_fltr_list_entry *f_entry) 3289 { 3290 struct ice_switch_info *sw = hw->switch_info; 3291 struct ice_fltr_info *new_fltr, *cur_fltr; 3292 struct ice_fltr_mgmt_list_entry *m_entry; 3293 struct mutex *rule_lock; /* Lock to protect filter rule list */ 3294 int status = 0; 3295 3296 if (!ice_is_vsi_valid(hw, f_entry->fltr_info.vsi_handle)) 3297 return -EINVAL; 3298 f_entry->fltr_info.fwd_id.hw_vsi_id = 3299 ice_get_hw_vsi_num(hw, f_entry->fltr_info.vsi_handle); 3300 3301 rule_lock = &sw->recp_list[recp_id].filt_rule_lock; 3302 3303 mutex_lock(rule_lock); 3304 new_fltr = &f_entry->fltr_info; 3305 if (new_fltr->flag & ICE_FLTR_RX) 3306 new_fltr->src = hw->port_info->lport; 3307 else if (new_fltr->flag & ICE_FLTR_TX) 3308 new_fltr->src = f_entry->fltr_info.fwd_id.hw_vsi_id; 3309 3310 m_entry = ice_find_rule_entry(hw, recp_id, new_fltr); 3311 if (!m_entry) { 3312 mutex_unlock(rule_lock); 3313 return ice_create_pkt_fwd_rule(hw, f_entry); 3314 } 3315 3316 cur_fltr = &m_entry->fltr_info; 3317 status = ice_add_update_vsi_list(hw, m_entry, cur_fltr, new_fltr); 3318 mutex_unlock(rule_lock); 3319 3320 return status; 3321 } 3322 3323 /** 3324 * ice_remove_vsi_list_rule 3325 * @hw: pointer to the hardware structure 3326 * @vsi_list_id: VSI list ID generated as part of allocate resource 3327 * @lkup_type: switch rule filter lookup type 3328 * 3329 * The VSI list should be emptied before this function is called to remove the 3330 * VSI list. 3331 */ 3332 static int 3333 ice_remove_vsi_list_rule(struct ice_hw *hw, u16 vsi_list_id, 3334 enum ice_sw_lkup_type lkup_type) 3335 { 3336 struct ice_sw_rule_vsi_list *s_rule; 3337 u16 s_rule_size; 3338 int status; 3339 3340 s_rule_size = (u16)ICE_SW_RULE_VSI_LIST_SIZE(s_rule, 0); 3341 s_rule = devm_kzalloc(ice_hw_to_dev(hw), s_rule_size, GFP_KERNEL); 3342 if (!s_rule) 3343 return -ENOMEM; 3344 3345 s_rule->hdr.type = cpu_to_le16(ICE_AQC_SW_RULES_T_VSI_LIST_CLEAR); 3346 s_rule->index = cpu_to_le16(vsi_list_id); 3347 3348 /* Free the vsi_list resource that we allocated. It is assumed that the 3349 * list is empty at this point. 3350 */ 3351 status = ice_aq_alloc_free_vsi_list(hw, &vsi_list_id, lkup_type, 3352 ice_aqc_opc_free_res); 3353 3354 devm_kfree(ice_hw_to_dev(hw), s_rule); 3355 return status; 3356 } 3357 3358 /** 3359 * ice_rem_update_vsi_list 3360 * @hw: pointer to the hardware structure 3361 * @vsi_handle: VSI handle of the VSI to remove 3362 * @fm_list: filter management entry for which the VSI list management needs to 3363 * be done 3364 */ 3365 static int 3366 ice_rem_update_vsi_list(struct ice_hw *hw, u16 vsi_handle, 3367 struct ice_fltr_mgmt_list_entry *fm_list) 3368 { 3369 enum ice_sw_lkup_type lkup_type; 3370 u16 vsi_list_id; 3371 int status = 0; 3372 3373 if (fm_list->fltr_info.fltr_act != ICE_FWD_TO_VSI_LIST || 3374 fm_list->vsi_count == 0) 3375 return -EINVAL; 3376 3377 /* A rule with the VSI being removed does not exist */ 3378 if (!test_bit(vsi_handle, fm_list->vsi_list_info->vsi_map)) 3379 return -ENOENT; 3380 3381 lkup_type = fm_list->fltr_info.lkup_type; 3382 vsi_list_id = fm_list->fltr_info.fwd_id.vsi_list_id; 3383 status = ice_update_vsi_list_rule(hw, &vsi_handle, 1, vsi_list_id, true, 3384 ice_aqc_opc_update_sw_rules, 3385 lkup_type); 3386 if (status) 3387 return status; 3388 3389 fm_list->vsi_count--; 3390 clear_bit(vsi_handle, fm_list->vsi_list_info->vsi_map); 3391 3392 if (fm_list->vsi_count == 1 && lkup_type != ICE_SW_LKUP_VLAN) { 3393 struct ice_fltr_info tmp_fltr_info = fm_list->fltr_info; 3394 struct ice_vsi_list_map_info *vsi_list_info = 3395 fm_list->vsi_list_info; 3396 u16 rem_vsi_handle; 3397 3398 rem_vsi_handle = find_first_bit(vsi_list_info->vsi_map, 3399 ICE_MAX_VSI); 3400 if (!ice_is_vsi_valid(hw, rem_vsi_handle)) 3401 return -EIO; 3402 3403 /* Make sure VSI list is empty before removing it below */ 3404 status = ice_update_vsi_list_rule(hw, &rem_vsi_handle, 1, 3405 vsi_list_id, true, 3406 ice_aqc_opc_update_sw_rules, 3407 lkup_type); 3408 if (status) 3409 return status; 3410 3411 tmp_fltr_info.fltr_act = ICE_FWD_TO_VSI; 3412 tmp_fltr_info.fwd_id.hw_vsi_id = 3413 ice_get_hw_vsi_num(hw, rem_vsi_handle); 3414 tmp_fltr_info.vsi_handle = rem_vsi_handle; 3415 status = ice_update_pkt_fwd_rule(hw, &tmp_fltr_info); 3416 if (status) { 3417 ice_debug(hw, ICE_DBG_SW, "Failed to update pkt fwd rule to FWD_TO_VSI on HW VSI %d, error %d\n", 3418 tmp_fltr_info.fwd_id.hw_vsi_id, status); 3419 return status; 3420 } 3421 3422 fm_list->fltr_info = tmp_fltr_info; 3423 } 3424 3425 if ((fm_list->vsi_count == 1 && lkup_type != ICE_SW_LKUP_VLAN) || 3426 (fm_list->vsi_count == 0 && lkup_type == ICE_SW_LKUP_VLAN)) { 3427 struct ice_vsi_list_map_info *vsi_list_info = 3428 fm_list->vsi_list_info; 3429 3430 /* Remove the VSI list since it is no longer used */ 3431 status = ice_remove_vsi_list_rule(hw, vsi_list_id, lkup_type); 3432 if (status) { 3433 ice_debug(hw, ICE_DBG_SW, "Failed to remove VSI list %d, error %d\n", 3434 vsi_list_id, status); 3435 return status; 3436 } 3437 3438 list_del(&vsi_list_info->list_entry); 3439 devm_kfree(ice_hw_to_dev(hw), vsi_list_info); 3440 fm_list->vsi_list_info = NULL; 3441 } 3442 3443 return status; 3444 } 3445 3446 /** 3447 * ice_remove_rule_internal - Remove a filter rule of a given type 3448 * @hw: pointer to the hardware structure 3449 * @recp_id: recipe ID for which the rule needs to removed 3450 * @f_entry: rule entry containing filter information 3451 */ 3452 static int 3453 ice_remove_rule_internal(struct ice_hw *hw, u8 recp_id, 3454 struct ice_fltr_list_entry *f_entry) 3455 { 3456 struct ice_switch_info *sw = hw->switch_info; 3457 struct ice_fltr_mgmt_list_entry *list_elem; 3458 struct mutex *rule_lock; /* Lock to protect filter rule list */ 3459 bool remove_rule = false; 3460 u16 vsi_handle; 3461 int status = 0; 3462 3463 if (!ice_is_vsi_valid(hw, f_entry->fltr_info.vsi_handle)) 3464 return -EINVAL; 3465 f_entry->fltr_info.fwd_id.hw_vsi_id = 3466 ice_get_hw_vsi_num(hw, f_entry->fltr_info.vsi_handle); 3467 3468 rule_lock = &sw->recp_list[recp_id].filt_rule_lock; 3469 mutex_lock(rule_lock); 3470 list_elem = ice_find_rule_entry(hw, recp_id, &f_entry->fltr_info); 3471 if (!list_elem) { 3472 status = -ENOENT; 3473 goto exit; 3474 } 3475 3476 if (list_elem->fltr_info.fltr_act != ICE_FWD_TO_VSI_LIST) { 3477 remove_rule = true; 3478 } else if (!list_elem->vsi_list_info) { 3479 status = -ENOENT; 3480 goto exit; 3481 } else if (list_elem->vsi_list_info->ref_cnt > 1) { 3482 /* a ref_cnt > 1 indicates that the vsi_list is being 3483 * shared by multiple rules. Decrement the ref_cnt and 3484 * remove this rule, but do not modify the list, as it 3485 * is in-use by other rules. 3486 */ 3487 list_elem->vsi_list_info->ref_cnt--; 3488 remove_rule = true; 3489 } else { 3490 /* a ref_cnt of 1 indicates the vsi_list is only used 3491 * by one rule. However, the original removal request is only 3492 * for a single VSI. Update the vsi_list first, and only 3493 * remove the rule if there are no further VSIs in this list. 3494 */ 3495 vsi_handle = f_entry->fltr_info.vsi_handle; 3496 status = ice_rem_update_vsi_list(hw, vsi_handle, list_elem); 3497 if (status) 3498 goto exit; 3499 /* if VSI count goes to zero after updating the VSI list */ 3500 if (list_elem->vsi_count == 0) 3501 remove_rule = true; 3502 } 3503 3504 if (remove_rule) { 3505 /* Remove the lookup rule */ 3506 struct ice_sw_rule_lkup_rx_tx *s_rule; 3507 3508 s_rule = devm_kzalloc(ice_hw_to_dev(hw), 3509 ICE_SW_RULE_RX_TX_NO_HDR_SIZE(s_rule), 3510 GFP_KERNEL); 3511 if (!s_rule) { 3512 status = -ENOMEM; 3513 goto exit; 3514 } 3515 3516 ice_fill_sw_rule(hw, &list_elem->fltr_info, s_rule, 3517 ice_aqc_opc_remove_sw_rules); 3518 3519 status = ice_aq_sw_rules(hw, s_rule, 3520 ICE_SW_RULE_RX_TX_NO_HDR_SIZE(s_rule), 3521 1, ice_aqc_opc_remove_sw_rules, NULL); 3522 3523 /* Remove a book keeping from the list */ 3524 devm_kfree(ice_hw_to_dev(hw), s_rule); 3525 3526 if (status) 3527 goto exit; 3528 3529 list_del(&list_elem->list_entry); 3530 devm_kfree(ice_hw_to_dev(hw), list_elem); 3531 } 3532 exit: 3533 mutex_unlock(rule_lock); 3534 return status; 3535 } 3536 3537 /** 3538 * ice_vlan_fltr_exist - does this VLAN filter exist for given VSI 3539 * @hw: pointer to the hardware structure 3540 * @vlan_id: VLAN ID 3541 * @vsi_handle: check MAC filter for this VSI 3542 */ 3543 bool ice_vlan_fltr_exist(struct ice_hw *hw, u16 vlan_id, u16 vsi_handle) 3544 { 3545 struct ice_fltr_mgmt_list_entry *entry; 3546 struct list_head *rule_head; 3547 struct ice_switch_info *sw; 3548 struct mutex *rule_lock; /* Lock to protect filter rule list */ 3549 u16 hw_vsi_id; 3550 3551 if (vlan_id > ICE_MAX_VLAN_ID) 3552 return false; 3553 3554 if (!ice_is_vsi_valid(hw, vsi_handle)) 3555 return false; 3556 3557 hw_vsi_id = ice_get_hw_vsi_num(hw, vsi_handle); 3558 sw = hw->switch_info; 3559 rule_head = &sw->recp_list[ICE_SW_LKUP_VLAN].filt_rules; 3560 if (!rule_head) 3561 return false; 3562 3563 rule_lock = &sw->recp_list[ICE_SW_LKUP_VLAN].filt_rule_lock; 3564 mutex_lock(rule_lock); 3565 list_for_each_entry(entry, rule_head, list_entry) { 3566 struct ice_fltr_info *f_info = &entry->fltr_info; 3567 u16 entry_vlan_id = f_info->l_data.vlan.vlan_id; 3568 struct ice_vsi_list_map_info *map_info; 3569 3570 if (entry_vlan_id > ICE_MAX_VLAN_ID) 3571 continue; 3572 3573 if (f_info->flag != ICE_FLTR_TX || 3574 f_info->src_id != ICE_SRC_ID_VSI || 3575 f_info->lkup_type != ICE_SW_LKUP_VLAN) 3576 continue; 3577 3578 /* Only allowed filter action are FWD_TO_VSI/_VSI_LIST */ 3579 if (f_info->fltr_act != ICE_FWD_TO_VSI && 3580 f_info->fltr_act != ICE_FWD_TO_VSI_LIST) 3581 continue; 3582 3583 if (f_info->fltr_act == ICE_FWD_TO_VSI) { 3584 if (hw_vsi_id != f_info->fwd_id.hw_vsi_id) 3585 continue; 3586 } else if (f_info->fltr_act == ICE_FWD_TO_VSI_LIST) { 3587 /* If filter_action is FWD_TO_VSI_LIST, make sure 3588 * that VSI being checked is part of VSI list 3589 */ 3590 if (entry->vsi_count == 1 && 3591 entry->vsi_list_info) { 3592 map_info = entry->vsi_list_info; 3593 if (!test_bit(vsi_handle, map_info->vsi_map)) 3594 continue; 3595 } 3596 } 3597 3598 if (vlan_id == entry_vlan_id) { 3599 mutex_unlock(rule_lock); 3600 return true; 3601 } 3602 } 3603 mutex_unlock(rule_lock); 3604 3605 return false; 3606 } 3607 3608 /** 3609 * ice_add_mac - Add a MAC address based filter rule 3610 * @hw: pointer to the hardware structure 3611 * @m_list: list of MAC addresses and forwarding information 3612 */ 3613 int ice_add_mac(struct ice_hw *hw, struct list_head *m_list) 3614 { 3615 struct ice_fltr_list_entry *m_list_itr; 3616 int status = 0; 3617 3618 if (!m_list || !hw) 3619 return -EINVAL; 3620 3621 list_for_each_entry(m_list_itr, m_list, list_entry) { 3622 u8 *add = &m_list_itr->fltr_info.l_data.mac.mac_addr[0]; 3623 u16 vsi_handle; 3624 u16 hw_vsi_id; 3625 3626 m_list_itr->fltr_info.flag = ICE_FLTR_TX; 3627 vsi_handle = m_list_itr->fltr_info.vsi_handle; 3628 if (!ice_is_vsi_valid(hw, vsi_handle)) 3629 return -EINVAL; 3630 hw_vsi_id = ice_get_hw_vsi_num(hw, vsi_handle); 3631 m_list_itr->fltr_info.fwd_id.hw_vsi_id = hw_vsi_id; 3632 /* update the src in case it is VSI num */ 3633 if (m_list_itr->fltr_info.src_id != ICE_SRC_ID_VSI) 3634 return -EINVAL; 3635 m_list_itr->fltr_info.src = hw_vsi_id; 3636 if (m_list_itr->fltr_info.lkup_type != ICE_SW_LKUP_MAC || 3637 is_zero_ether_addr(add)) 3638 return -EINVAL; 3639 3640 m_list_itr->status = ice_add_rule_internal(hw, ICE_SW_LKUP_MAC, 3641 m_list_itr); 3642 if (m_list_itr->status) 3643 return m_list_itr->status; 3644 } 3645 3646 return status; 3647 } 3648 3649 /** 3650 * ice_add_vlan_internal - Add one VLAN based filter rule 3651 * @hw: pointer to the hardware structure 3652 * @f_entry: filter entry containing one VLAN information 3653 */ 3654 static int 3655 ice_add_vlan_internal(struct ice_hw *hw, struct ice_fltr_list_entry *f_entry) 3656 { 3657 struct ice_switch_info *sw = hw->switch_info; 3658 struct ice_fltr_mgmt_list_entry *v_list_itr; 3659 struct ice_fltr_info *new_fltr, *cur_fltr; 3660 enum ice_sw_lkup_type lkup_type; 3661 u16 vsi_list_id = 0, vsi_handle; 3662 struct mutex *rule_lock; /* Lock to protect filter rule list */ 3663 int status = 0; 3664 3665 if (!ice_is_vsi_valid(hw, f_entry->fltr_info.vsi_handle)) 3666 return -EINVAL; 3667 3668 f_entry->fltr_info.fwd_id.hw_vsi_id = 3669 ice_get_hw_vsi_num(hw, f_entry->fltr_info.vsi_handle); 3670 new_fltr = &f_entry->fltr_info; 3671 3672 /* VLAN ID should only be 12 bits */ 3673 if (new_fltr->l_data.vlan.vlan_id > ICE_MAX_VLAN_ID) 3674 return -EINVAL; 3675 3676 if (new_fltr->src_id != ICE_SRC_ID_VSI) 3677 return -EINVAL; 3678 3679 new_fltr->src = new_fltr->fwd_id.hw_vsi_id; 3680 lkup_type = new_fltr->lkup_type; 3681 vsi_handle = new_fltr->vsi_handle; 3682 rule_lock = &sw->recp_list[ICE_SW_LKUP_VLAN].filt_rule_lock; 3683 mutex_lock(rule_lock); 3684 v_list_itr = ice_find_rule_entry(hw, ICE_SW_LKUP_VLAN, new_fltr); 3685 if (!v_list_itr) { 3686 struct ice_vsi_list_map_info *map_info = NULL; 3687 3688 if (new_fltr->fltr_act == ICE_FWD_TO_VSI) { 3689 /* All VLAN pruning rules use a VSI list. Check if 3690 * there is already a VSI list containing VSI that we 3691 * want to add. If found, use the same vsi_list_id for 3692 * this new VLAN rule or else create a new list. 3693 */ 3694 map_info = ice_find_vsi_list_entry(hw, ICE_SW_LKUP_VLAN, 3695 vsi_handle, 3696 &vsi_list_id); 3697 if (!map_info) { 3698 status = ice_create_vsi_list_rule(hw, 3699 &vsi_handle, 3700 1, 3701 &vsi_list_id, 3702 lkup_type); 3703 if (status) 3704 goto exit; 3705 } 3706 /* Convert the action to forwarding to a VSI list. */ 3707 new_fltr->fltr_act = ICE_FWD_TO_VSI_LIST; 3708 new_fltr->fwd_id.vsi_list_id = vsi_list_id; 3709 } 3710 3711 status = ice_create_pkt_fwd_rule(hw, f_entry); 3712 if (!status) { 3713 v_list_itr = ice_find_rule_entry(hw, ICE_SW_LKUP_VLAN, 3714 new_fltr); 3715 if (!v_list_itr) { 3716 status = -ENOENT; 3717 goto exit; 3718 } 3719 /* reuse VSI list for new rule and increment ref_cnt */ 3720 if (map_info) { 3721 v_list_itr->vsi_list_info = map_info; 3722 map_info->ref_cnt++; 3723 } else { 3724 v_list_itr->vsi_list_info = 3725 ice_create_vsi_list_map(hw, &vsi_handle, 3726 1, vsi_list_id); 3727 } 3728 } 3729 } else if (v_list_itr->vsi_list_info->ref_cnt == 1) { 3730 /* Update existing VSI list to add new VSI ID only if it used 3731 * by one VLAN rule. 3732 */ 3733 cur_fltr = &v_list_itr->fltr_info; 3734 status = ice_add_update_vsi_list(hw, v_list_itr, cur_fltr, 3735 new_fltr); 3736 } else { 3737 /* If VLAN rule exists and VSI list being used by this rule is 3738 * referenced by more than 1 VLAN rule. Then create a new VSI 3739 * list appending previous VSI with new VSI and update existing 3740 * VLAN rule to point to new VSI list ID 3741 */ 3742 struct ice_fltr_info tmp_fltr; 3743 u16 vsi_handle_arr[2]; 3744 u16 cur_handle; 3745 3746 /* Current implementation only supports reusing VSI list with 3747 * one VSI count. We should never hit below condition 3748 */ 3749 if (v_list_itr->vsi_count > 1 && 3750 v_list_itr->vsi_list_info->ref_cnt > 1) { 3751 ice_debug(hw, ICE_DBG_SW, "Invalid configuration: Optimization to reuse VSI list with more than one VSI is not being done yet\n"); 3752 status = -EIO; 3753 goto exit; 3754 } 3755 3756 cur_handle = 3757 find_first_bit(v_list_itr->vsi_list_info->vsi_map, 3758 ICE_MAX_VSI); 3759 3760 /* A rule already exists with the new VSI being added */ 3761 if (cur_handle == vsi_handle) { 3762 status = -EEXIST; 3763 goto exit; 3764 } 3765 3766 vsi_handle_arr[0] = cur_handle; 3767 vsi_handle_arr[1] = vsi_handle; 3768 status = ice_create_vsi_list_rule(hw, &vsi_handle_arr[0], 2, 3769 &vsi_list_id, lkup_type); 3770 if (status) 3771 goto exit; 3772 3773 tmp_fltr = v_list_itr->fltr_info; 3774 tmp_fltr.fltr_rule_id = v_list_itr->fltr_info.fltr_rule_id; 3775 tmp_fltr.fwd_id.vsi_list_id = vsi_list_id; 3776 tmp_fltr.fltr_act = ICE_FWD_TO_VSI_LIST; 3777 /* Update the previous switch rule to a new VSI list which 3778 * includes current VSI that is requested 3779 */ 3780 status = ice_update_pkt_fwd_rule(hw, &tmp_fltr); 3781 if (status) 3782 goto exit; 3783 3784 /* before overriding VSI list map info. decrement ref_cnt of 3785 * previous VSI list 3786 */ 3787 v_list_itr->vsi_list_info->ref_cnt--; 3788 3789 /* now update to newly created list */ 3790 v_list_itr->fltr_info.fwd_id.vsi_list_id = vsi_list_id; 3791 v_list_itr->vsi_list_info = 3792 ice_create_vsi_list_map(hw, &vsi_handle_arr[0], 2, 3793 vsi_list_id); 3794 v_list_itr->vsi_count++; 3795 } 3796 3797 exit: 3798 mutex_unlock(rule_lock); 3799 return status; 3800 } 3801 3802 /** 3803 * ice_add_vlan - Add VLAN based filter rule 3804 * @hw: pointer to the hardware structure 3805 * @v_list: list of VLAN entries and forwarding information 3806 */ 3807 int ice_add_vlan(struct ice_hw *hw, struct list_head *v_list) 3808 { 3809 struct ice_fltr_list_entry *v_list_itr; 3810 3811 if (!v_list || !hw) 3812 return -EINVAL; 3813 3814 list_for_each_entry(v_list_itr, v_list, list_entry) { 3815 if (v_list_itr->fltr_info.lkup_type != ICE_SW_LKUP_VLAN) 3816 return -EINVAL; 3817 v_list_itr->fltr_info.flag = ICE_FLTR_TX; 3818 v_list_itr->status = ice_add_vlan_internal(hw, v_list_itr); 3819 if (v_list_itr->status) 3820 return v_list_itr->status; 3821 } 3822 return 0; 3823 } 3824 3825 /** 3826 * ice_add_eth_mac - Add ethertype and MAC based filter rule 3827 * @hw: pointer to the hardware structure 3828 * @em_list: list of ether type MAC filter, MAC is optional 3829 * 3830 * This function requires the caller to populate the entries in 3831 * the filter list with the necessary fields (including flags to 3832 * indicate Tx or Rx rules). 3833 */ 3834 int ice_add_eth_mac(struct ice_hw *hw, struct list_head *em_list) 3835 { 3836 struct ice_fltr_list_entry *em_list_itr; 3837 3838 if (!em_list || !hw) 3839 return -EINVAL; 3840 3841 list_for_each_entry(em_list_itr, em_list, list_entry) { 3842 enum ice_sw_lkup_type l_type = 3843 em_list_itr->fltr_info.lkup_type; 3844 3845 if (l_type != ICE_SW_LKUP_ETHERTYPE_MAC && 3846 l_type != ICE_SW_LKUP_ETHERTYPE) 3847 return -EINVAL; 3848 3849 em_list_itr->status = ice_add_rule_internal(hw, l_type, 3850 em_list_itr); 3851 if (em_list_itr->status) 3852 return em_list_itr->status; 3853 } 3854 return 0; 3855 } 3856 3857 /** 3858 * ice_remove_eth_mac - Remove an ethertype (or MAC) based filter rule 3859 * @hw: pointer to the hardware structure 3860 * @em_list: list of ethertype or ethertype MAC entries 3861 */ 3862 int ice_remove_eth_mac(struct ice_hw *hw, struct list_head *em_list) 3863 { 3864 struct ice_fltr_list_entry *em_list_itr, *tmp; 3865 3866 if (!em_list || !hw) 3867 return -EINVAL; 3868 3869 list_for_each_entry_safe(em_list_itr, tmp, em_list, list_entry) { 3870 enum ice_sw_lkup_type l_type = 3871 em_list_itr->fltr_info.lkup_type; 3872 3873 if (l_type != ICE_SW_LKUP_ETHERTYPE_MAC && 3874 l_type != ICE_SW_LKUP_ETHERTYPE) 3875 return -EINVAL; 3876 3877 em_list_itr->status = ice_remove_rule_internal(hw, l_type, 3878 em_list_itr); 3879 if (em_list_itr->status) 3880 return em_list_itr->status; 3881 } 3882 return 0; 3883 } 3884 3885 /** 3886 * ice_rem_sw_rule_info 3887 * @hw: pointer to the hardware structure 3888 * @rule_head: pointer to the switch list structure that we want to delete 3889 */ 3890 static void 3891 ice_rem_sw_rule_info(struct ice_hw *hw, struct list_head *rule_head) 3892 { 3893 if (!list_empty(rule_head)) { 3894 struct ice_fltr_mgmt_list_entry *entry; 3895 struct ice_fltr_mgmt_list_entry *tmp; 3896 3897 list_for_each_entry_safe(entry, tmp, rule_head, list_entry) { 3898 list_del(&entry->list_entry); 3899 devm_kfree(ice_hw_to_dev(hw), entry); 3900 } 3901 } 3902 } 3903 3904 /** 3905 * ice_rem_adv_rule_info 3906 * @hw: pointer to the hardware structure 3907 * @rule_head: pointer to the switch list structure that we want to delete 3908 */ 3909 static void 3910 ice_rem_adv_rule_info(struct ice_hw *hw, struct list_head *rule_head) 3911 { 3912 struct ice_adv_fltr_mgmt_list_entry *tmp_entry; 3913 struct ice_adv_fltr_mgmt_list_entry *lst_itr; 3914 3915 if (list_empty(rule_head)) 3916 return; 3917 3918 list_for_each_entry_safe(lst_itr, tmp_entry, rule_head, list_entry) { 3919 list_del(&lst_itr->list_entry); 3920 devm_kfree(ice_hw_to_dev(hw), lst_itr->lkups); 3921 devm_kfree(ice_hw_to_dev(hw), lst_itr); 3922 } 3923 } 3924 3925 /** 3926 * ice_cfg_dflt_vsi - change state of VSI to set/clear default 3927 * @pi: pointer to the port_info structure 3928 * @vsi_handle: VSI handle to set as default 3929 * @set: true to add the above mentioned switch rule, false to remove it 3930 * @direction: ICE_FLTR_RX or ICE_FLTR_TX 3931 * 3932 * add filter rule to set/unset given VSI as default VSI for the switch 3933 * (represented by swid) 3934 */ 3935 int 3936 ice_cfg_dflt_vsi(struct ice_port_info *pi, u16 vsi_handle, bool set, 3937 u8 direction) 3938 { 3939 struct ice_fltr_list_entry f_list_entry; 3940 struct ice_fltr_info f_info; 3941 struct ice_hw *hw = pi->hw; 3942 u16 hw_vsi_id; 3943 int status; 3944 3945 if (!ice_is_vsi_valid(hw, vsi_handle)) 3946 return -EINVAL; 3947 3948 hw_vsi_id = ice_get_hw_vsi_num(hw, vsi_handle); 3949 3950 memset(&f_info, 0, sizeof(f_info)); 3951 3952 f_info.lkup_type = ICE_SW_LKUP_DFLT; 3953 f_info.flag = direction; 3954 f_info.fltr_act = ICE_FWD_TO_VSI; 3955 f_info.fwd_id.hw_vsi_id = hw_vsi_id; 3956 f_info.vsi_handle = vsi_handle; 3957 3958 if (f_info.flag & ICE_FLTR_RX) { 3959 f_info.src = hw->port_info->lport; 3960 f_info.src_id = ICE_SRC_ID_LPORT; 3961 } else if (f_info.flag & ICE_FLTR_TX) { 3962 f_info.src_id = ICE_SRC_ID_VSI; 3963 f_info.src = hw_vsi_id; 3964 f_info.flag |= ICE_FLTR_TX_ONLY; 3965 } 3966 f_list_entry.fltr_info = f_info; 3967 3968 if (set) 3969 status = ice_add_rule_internal(hw, ICE_SW_LKUP_DFLT, 3970 &f_list_entry); 3971 else 3972 status = ice_remove_rule_internal(hw, ICE_SW_LKUP_DFLT, 3973 &f_list_entry); 3974 3975 return status; 3976 } 3977 3978 /** 3979 * ice_vsi_uses_fltr - Determine if given VSI uses specified filter 3980 * @fm_entry: filter entry to inspect 3981 * @vsi_handle: VSI handle to compare with filter info 3982 */ 3983 static bool 3984 ice_vsi_uses_fltr(struct ice_fltr_mgmt_list_entry *fm_entry, u16 vsi_handle) 3985 { 3986 return ((fm_entry->fltr_info.fltr_act == ICE_FWD_TO_VSI && 3987 fm_entry->fltr_info.vsi_handle == vsi_handle) || 3988 (fm_entry->fltr_info.fltr_act == ICE_FWD_TO_VSI_LIST && 3989 fm_entry->vsi_list_info && 3990 (test_bit(vsi_handle, fm_entry->vsi_list_info->vsi_map)))); 3991 } 3992 3993 /** 3994 * ice_check_if_dflt_vsi - check if VSI is default VSI 3995 * @pi: pointer to the port_info structure 3996 * @vsi_handle: vsi handle to check for in filter list 3997 * @rule_exists: indicates if there are any VSI's in the rule list 3998 * 3999 * checks if the VSI is in a default VSI list, and also indicates 4000 * if the default VSI list is empty 4001 */ 4002 bool 4003 ice_check_if_dflt_vsi(struct ice_port_info *pi, u16 vsi_handle, 4004 bool *rule_exists) 4005 { 4006 struct ice_fltr_mgmt_list_entry *fm_entry; 4007 struct ice_sw_recipe *recp_list; 4008 struct list_head *rule_head; 4009 struct mutex *rule_lock; /* Lock to protect filter rule list */ 4010 bool ret = false; 4011 4012 recp_list = &pi->hw->switch_info->recp_list[ICE_SW_LKUP_DFLT]; 4013 rule_lock = &recp_list->filt_rule_lock; 4014 rule_head = &recp_list->filt_rules; 4015 4016 mutex_lock(rule_lock); 4017 4018 if (rule_exists && !list_empty(rule_head)) 4019 *rule_exists = true; 4020 4021 list_for_each_entry(fm_entry, rule_head, list_entry) { 4022 if (ice_vsi_uses_fltr(fm_entry, vsi_handle)) { 4023 ret = true; 4024 break; 4025 } 4026 } 4027 4028 mutex_unlock(rule_lock); 4029 4030 return ret; 4031 } 4032 4033 /** 4034 * ice_remove_mac - remove a MAC address based filter rule 4035 * @hw: pointer to the hardware structure 4036 * @m_list: list of MAC addresses and forwarding information 4037 * 4038 * This function removes either a MAC filter rule or a specific VSI from a 4039 * VSI list for a multicast MAC address. 4040 * 4041 * Returns -ENOENT if a given entry was not added by ice_add_mac. Caller should 4042 * be aware that this call will only work if all the entries passed into m_list 4043 * were added previously. It will not attempt to do a partial remove of entries 4044 * that were found. 4045 */ 4046 int ice_remove_mac(struct ice_hw *hw, struct list_head *m_list) 4047 { 4048 struct ice_fltr_list_entry *list_itr, *tmp; 4049 4050 if (!m_list) 4051 return -EINVAL; 4052 4053 list_for_each_entry_safe(list_itr, tmp, m_list, list_entry) { 4054 enum ice_sw_lkup_type l_type = list_itr->fltr_info.lkup_type; 4055 u16 vsi_handle; 4056 4057 if (l_type != ICE_SW_LKUP_MAC) 4058 return -EINVAL; 4059 4060 vsi_handle = list_itr->fltr_info.vsi_handle; 4061 if (!ice_is_vsi_valid(hw, vsi_handle)) 4062 return -EINVAL; 4063 4064 list_itr->fltr_info.fwd_id.hw_vsi_id = 4065 ice_get_hw_vsi_num(hw, vsi_handle); 4066 4067 list_itr->status = ice_remove_rule_internal(hw, 4068 ICE_SW_LKUP_MAC, 4069 list_itr); 4070 if (list_itr->status) 4071 return list_itr->status; 4072 } 4073 return 0; 4074 } 4075 4076 /** 4077 * ice_remove_vlan - Remove VLAN based filter rule 4078 * @hw: pointer to the hardware structure 4079 * @v_list: list of VLAN entries and forwarding information 4080 */ 4081 int ice_remove_vlan(struct ice_hw *hw, struct list_head *v_list) 4082 { 4083 struct ice_fltr_list_entry *v_list_itr, *tmp; 4084 4085 if (!v_list || !hw) 4086 return -EINVAL; 4087 4088 list_for_each_entry_safe(v_list_itr, tmp, v_list, list_entry) { 4089 enum ice_sw_lkup_type l_type = v_list_itr->fltr_info.lkup_type; 4090 4091 if (l_type != ICE_SW_LKUP_VLAN) 4092 return -EINVAL; 4093 v_list_itr->status = ice_remove_rule_internal(hw, 4094 ICE_SW_LKUP_VLAN, 4095 v_list_itr); 4096 if (v_list_itr->status) 4097 return v_list_itr->status; 4098 } 4099 return 0; 4100 } 4101 4102 /** 4103 * ice_add_entry_to_vsi_fltr_list - Add copy of fltr_list_entry to remove list 4104 * @hw: pointer to the hardware structure 4105 * @vsi_handle: VSI handle to remove filters from 4106 * @vsi_list_head: pointer to the list to add entry to 4107 * @fi: pointer to fltr_info of filter entry to copy & add 4108 * 4109 * Helper function, used when creating a list of filters to remove from 4110 * a specific VSI. The entry added to vsi_list_head is a COPY of the 4111 * original filter entry, with the exception of fltr_info.fltr_act and 4112 * fltr_info.fwd_id fields. These are set such that later logic can 4113 * extract which VSI to remove the fltr from, and pass on that information. 4114 */ 4115 static int 4116 ice_add_entry_to_vsi_fltr_list(struct ice_hw *hw, u16 vsi_handle, 4117 struct list_head *vsi_list_head, 4118 struct ice_fltr_info *fi) 4119 { 4120 struct ice_fltr_list_entry *tmp; 4121 4122 /* this memory is freed up in the caller function 4123 * once filters for this VSI are removed 4124 */ 4125 tmp = devm_kzalloc(ice_hw_to_dev(hw), sizeof(*tmp), GFP_KERNEL); 4126 if (!tmp) 4127 return -ENOMEM; 4128 4129 tmp->fltr_info = *fi; 4130 4131 /* Overwrite these fields to indicate which VSI to remove filter from, 4132 * so find and remove logic can extract the information from the 4133 * list entries. Note that original entries will still have proper 4134 * values. 4135 */ 4136 tmp->fltr_info.fltr_act = ICE_FWD_TO_VSI; 4137 tmp->fltr_info.vsi_handle = vsi_handle; 4138 tmp->fltr_info.fwd_id.hw_vsi_id = ice_get_hw_vsi_num(hw, vsi_handle); 4139 4140 list_add(&tmp->list_entry, vsi_list_head); 4141 4142 return 0; 4143 } 4144 4145 /** 4146 * ice_add_to_vsi_fltr_list - Add VSI filters to the list 4147 * @hw: pointer to the hardware structure 4148 * @vsi_handle: VSI handle to remove filters from 4149 * @lkup_list_head: pointer to the list that has certain lookup type filters 4150 * @vsi_list_head: pointer to the list pertaining to VSI with vsi_handle 4151 * 4152 * Locates all filters in lkup_list_head that are used by the given VSI, 4153 * and adds COPIES of those entries to vsi_list_head (intended to be used 4154 * to remove the listed filters). 4155 * Note that this means all entries in vsi_list_head must be explicitly 4156 * deallocated by the caller when done with list. 4157 */ 4158 static int 4159 ice_add_to_vsi_fltr_list(struct ice_hw *hw, u16 vsi_handle, 4160 struct list_head *lkup_list_head, 4161 struct list_head *vsi_list_head) 4162 { 4163 struct ice_fltr_mgmt_list_entry *fm_entry; 4164 int status = 0; 4165 4166 /* check to make sure VSI ID is valid and within boundary */ 4167 if (!ice_is_vsi_valid(hw, vsi_handle)) 4168 return -EINVAL; 4169 4170 list_for_each_entry(fm_entry, lkup_list_head, list_entry) { 4171 if (!ice_vsi_uses_fltr(fm_entry, vsi_handle)) 4172 continue; 4173 4174 status = ice_add_entry_to_vsi_fltr_list(hw, vsi_handle, 4175 vsi_list_head, 4176 &fm_entry->fltr_info); 4177 if (status) 4178 return status; 4179 } 4180 return status; 4181 } 4182 4183 /** 4184 * ice_determine_promisc_mask 4185 * @fi: filter info to parse 4186 * 4187 * Helper function to determine which ICE_PROMISC_ mask corresponds 4188 * to given filter into. 4189 */ 4190 static u8 ice_determine_promisc_mask(struct ice_fltr_info *fi) 4191 { 4192 u16 vid = fi->l_data.mac_vlan.vlan_id; 4193 u8 *macaddr = fi->l_data.mac.mac_addr; 4194 bool is_tx_fltr = false; 4195 u8 promisc_mask = 0; 4196 4197 if (fi->flag == ICE_FLTR_TX) 4198 is_tx_fltr = true; 4199 4200 if (is_broadcast_ether_addr(macaddr)) 4201 promisc_mask |= is_tx_fltr ? 4202 ICE_PROMISC_BCAST_TX : ICE_PROMISC_BCAST_RX; 4203 else if (is_multicast_ether_addr(macaddr)) 4204 promisc_mask |= is_tx_fltr ? 4205 ICE_PROMISC_MCAST_TX : ICE_PROMISC_MCAST_RX; 4206 else if (is_unicast_ether_addr(macaddr)) 4207 promisc_mask |= is_tx_fltr ? 4208 ICE_PROMISC_UCAST_TX : ICE_PROMISC_UCAST_RX; 4209 if (vid) 4210 promisc_mask |= is_tx_fltr ? 4211 ICE_PROMISC_VLAN_TX : ICE_PROMISC_VLAN_RX; 4212 4213 return promisc_mask; 4214 } 4215 4216 /** 4217 * ice_remove_promisc - Remove promisc based filter rules 4218 * @hw: pointer to the hardware structure 4219 * @recp_id: recipe ID for which the rule needs to removed 4220 * @v_list: list of promisc entries 4221 */ 4222 static int 4223 ice_remove_promisc(struct ice_hw *hw, u8 recp_id, struct list_head *v_list) 4224 { 4225 struct ice_fltr_list_entry *v_list_itr, *tmp; 4226 4227 list_for_each_entry_safe(v_list_itr, tmp, v_list, list_entry) { 4228 v_list_itr->status = 4229 ice_remove_rule_internal(hw, recp_id, v_list_itr); 4230 if (v_list_itr->status) 4231 return v_list_itr->status; 4232 } 4233 return 0; 4234 } 4235 4236 /** 4237 * ice_clear_vsi_promisc - clear specified promiscuous mode(s) for given VSI 4238 * @hw: pointer to the hardware structure 4239 * @vsi_handle: VSI handle to clear mode 4240 * @promisc_mask: mask of promiscuous config bits to clear 4241 * @vid: VLAN ID to clear VLAN promiscuous 4242 */ 4243 int 4244 ice_clear_vsi_promisc(struct ice_hw *hw, u16 vsi_handle, u8 promisc_mask, 4245 u16 vid) 4246 { 4247 struct ice_switch_info *sw = hw->switch_info; 4248 struct ice_fltr_list_entry *fm_entry, *tmp; 4249 struct list_head remove_list_head; 4250 struct ice_fltr_mgmt_list_entry *itr; 4251 struct list_head *rule_head; 4252 struct mutex *rule_lock; /* Lock to protect filter rule list */ 4253 int status = 0; 4254 u8 recipe_id; 4255 4256 if (!ice_is_vsi_valid(hw, vsi_handle)) 4257 return -EINVAL; 4258 4259 if (promisc_mask & (ICE_PROMISC_VLAN_RX | ICE_PROMISC_VLAN_TX)) 4260 recipe_id = ICE_SW_LKUP_PROMISC_VLAN; 4261 else 4262 recipe_id = ICE_SW_LKUP_PROMISC; 4263 4264 rule_head = &sw->recp_list[recipe_id].filt_rules; 4265 rule_lock = &sw->recp_list[recipe_id].filt_rule_lock; 4266 4267 INIT_LIST_HEAD(&remove_list_head); 4268 4269 mutex_lock(rule_lock); 4270 list_for_each_entry(itr, rule_head, list_entry) { 4271 struct ice_fltr_info *fltr_info; 4272 u8 fltr_promisc_mask = 0; 4273 4274 if (!ice_vsi_uses_fltr(itr, vsi_handle)) 4275 continue; 4276 fltr_info = &itr->fltr_info; 4277 4278 if (recipe_id == ICE_SW_LKUP_PROMISC_VLAN && 4279 vid != fltr_info->l_data.mac_vlan.vlan_id) 4280 continue; 4281 4282 fltr_promisc_mask |= ice_determine_promisc_mask(fltr_info); 4283 4284 /* Skip if filter is not completely specified by given mask */ 4285 if (fltr_promisc_mask & ~promisc_mask) 4286 continue; 4287 4288 status = ice_add_entry_to_vsi_fltr_list(hw, vsi_handle, 4289 &remove_list_head, 4290 fltr_info); 4291 if (status) { 4292 mutex_unlock(rule_lock); 4293 goto free_fltr_list; 4294 } 4295 } 4296 mutex_unlock(rule_lock); 4297 4298 status = ice_remove_promisc(hw, recipe_id, &remove_list_head); 4299 4300 free_fltr_list: 4301 list_for_each_entry_safe(fm_entry, tmp, &remove_list_head, list_entry) { 4302 list_del(&fm_entry->list_entry); 4303 devm_kfree(ice_hw_to_dev(hw), fm_entry); 4304 } 4305 4306 return status; 4307 } 4308 4309 /** 4310 * ice_set_vsi_promisc - set given VSI to given promiscuous mode(s) 4311 * @hw: pointer to the hardware structure 4312 * @vsi_handle: VSI handle to configure 4313 * @promisc_mask: mask of promiscuous config bits 4314 * @vid: VLAN ID to set VLAN promiscuous 4315 */ 4316 int 4317 ice_set_vsi_promisc(struct ice_hw *hw, u16 vsi_handle, u8 promisc_mask, u16 vid) 4318 { 4319 enum { UCAST_FLTR = 1, MCAST_FLTR, BCAST_FLTR }; 4320 struct ice_fltr_list_entry f_list_entry; 4321 struct ice_fltr_info new_fltr; 4322 bool is_tx_fltr; 4323 int status = 0; 4324 u16 hw_vsi_id; 4325 int pkt_type; 4326 u8 recipe_id; 4327 4328 if (!ice_is_vsi_valid(hw, vsi_handle)) 4329 return -EINVAL; 4330 hw_vsi_id = ice_get_hw_vsi_num(hw, vsi_handle); 4331 4332 memset(&new_fltr, 0, sizeof(new_fltr)); 4333 4334 if (promisc_mask & (ICE_PROMISC_VLAN_RX | ICE_PROMISC_VLAN_TX)) { 4335 new_fltr.lkup_type = ICE_SW_LKUP_PROMISC_VLAN; 4336 new_fltr.l_data.mac_vlan.vlan_id = vid; 4337 recipe_id = ICE_SW_LKUP_PROMISC_VLAN; 4338 } else { 4339 new_fltr.lkup_type = ICE_SW_LKUP_PROMISC; 4340 recipe_id = ICE_SW_LKUP_PROMISC; 4341 } 4342 4343 /* Separate filters must be set for each direction/packet type 4344 * combination, so we will loop over the mask value, store the 4345 * individual type, and clear it out in the input mask as it 4346 * is found. 4347 */ 4348 while (promisc_mask) { 4349 u8 *mac_addr; 4350 4351 pkt_type = 0; 4352 is_tx_fltr = false; 4353 4354 if (promisc_mask & ICE_PROMISC_UCAST_RX) { 4355 promisc_mask &= ~ICE_PROMISC_UCAST_RX; 4356 pkt_type = UCAST_FLTR; 4357 } else if (promisc_mask & ICE_PROMISC_UCAST_TX) { 4358 promisc_mask &= ~ICE_PROMISC_UCAST_TX; 4359 pkt_type = UCAST_FLTR; 4360 is_tx_fltr = true; 4361 } else if (promisc_mask & ICE_PROMISC_MCAST_RX) { 4362 promisc_mask &= ~ICE_PROMISC_MCAST_RX; 4363 pkt_type = MCAST_FLTR; 4364 } else if (promisc_mask & ICE_PROMISC_MCAST_TX) { 4365 promisc_mask &= ~ICE_PROMISC_MCAST_TX; 4366 pkt_type = MCAST_FLTR; 4367 is_tx_fltr = true; 4368 } else if (promisc_mask & ICE_PROMISC_BCAST_RX) { 4369 promisc_mask &= ~ICE_PROMISC_BCAST_RX; 4370 pkt_type = BCAST_FLTR; 4371 } else if (promisc_mask & ICE_PROMISC_BCAST_TX) { 4372 promisc_mask &= ~ICE_PROMISC_BCAST_TX; 4373 pkt_type = BCAST_FLTR; 4374 is_tx_fltr = true; 4375 } 4376 4377 /* Check for VLAN promiscuous flag */ 4378 if (promisc_mask & ICE_PROMISC_VLAN_RX) { 4379 promisc_mask &= ~ICE_PROMISC_VLAN_RX; 4380 } else if (promisc_mask & ICE_PROMISC_VLAN_TX) { 4381 promisc_mask &= ~ICE_PROMISC_VLAN_TX; 4382 is_tx_fltr = true; 4383 } 4384 4385 /* Set filter DA based on packet type */ 4386 mac_addr = new_fltr.l_data.mac.mac_addr; 4387 if (pkt_type == BCAST_FLTR) { 4388 eth_broadcast_addr(mac_addr); 4389 } else if (pkt_type == MCAST_FLTR || 4390 pkt_type == UCAST_FLTR) { 4391 /* Use the dummy ether header DA */ 4392 ether_addr_copy(mac_addr, dummy_eth_header); 4393 if (pkt_type == MCAST_FLTR) 4394 mac_addr[0] |= 0x1; /* Set multicast bit */ 4395 } 4396 4397 /* Need to reset this to zero for all iterations */ 4398 new_fltr.flag = 0; 4399 if (is_tx_fltr) { 4400 new_fltr.flag |= ICE_FLTR_TX; 4401 new_fltr.src = hw_vsi_id; 4402 } else { 4403 new_fltr.flag |= ICE_FLTR_RX; 4404 new_fltr.src = hw->port_info->lport; 4405 } 4406 4407 new_fltr.fltr_act = ICE_FWD_TO_VSI; 4408 new_fltr.vsi_handle = vsi_handle; 4409 new_fltr.fwd_id.hw_vsi_id = hw_vsi_id; 4410 f_list_entry.fltr_info = new_fltr; 4411 4412 status = ice_add_rule_internal(hw, recipe_id, &f_list_entry); 4413 if (status) 4414 goto set_promisc_exit; 4415 } 4416 4417 set_promisc_exit: 4418 return status; 4419 } 4420 4421 /** 4422 * ice_set_vlan_vsi_promisc 4423 * @hw: pointer to the hardware structure 4424 * @vsi_handle: VSI handle to configure 4425 * @promisc_mask: mask of promiscuous config bits 4426 * @rm_vlan_promisc: Clear VLANs VSI promisc mode 4427 * 4428 * Configure VSI with all associated VLANs to given promiscuous mode(s) 4429 */ 4430 int 4431 ice_set_vlan_vsi_promisc(struct ice_hw *hw, u16 vsi_handle, u8 promisc_mask, 4432 bool rm_vlan_promisc) 4433 { 4434 struct ice_switch_info *sw = hw->switch_info; 4435 struct ice_fltr_list_entry *list_itr, *tmp; 4436 struct list_head vsi_list_head; 4437 struct list_head *vlan_head; 4438 struct mutex *vlan_lock; /* Lock to protect filter rule list */ 4439 u16 vlan_id; 4440 int status; 4441 4442 INIT_LIST_HEAD(&vsi_list_head); 4443 vlan_lock = &sw->recp_list[ICE_SW_LKUP_VLAN].filt_rule_lock; 4444 vlan_head = &sw->recp_list[ICE_SW_LKUP_VLAN].filt_rules; 4445 mutex_lock(vlan_lock); 4446 status = ice_add_to_vsi_fltr_list(hw, vsi_handle, vlan_head, 4447 &vsi_list_head); 4448 mutex_unlock(vlan_lock); 4449 if (status) 4450 goto free_fltr_list; 4451 4452 list_for_each_entry(list_itr, &vsi_list_head, list_entry) { 4453 /* Avoid enabling or disabling VLAN zero twice when in double 4454 * VLAN mode 4455 */ 4456 if (ice_is_dvm_ena(hw) && 4457 list_itr->fltr_info.l_data.vlan.tpid == 0) 4458 continue; 4459 4460 vlan_id = list_itr->fltr_info.l_data.vlan.vlan_id; 4461 if (rm_vlan_promisc) 4462 status = ice_clear_vsi_promisc(hw, vsi_handle, 4463 promisc_mask, vlan_id); 4464 else 4465 status = ice_set_vsi_promisc(hw, vsi_handle, 4466 promisc_mask, vlan_id); 4467 if (status && status != -EEXIST) 4468 break; 4469 } 4470 4471 free_fltr_list: 4472 list_for_each_entry_safe(list_itr, tmp, &vsi_list_head, list_entry) { 4473 list_del(&list_itr->list_entry); 4474 devm_kfree(ice_hw_to_dev(hw), list_itr); 4475 } 4476 return status; 4477 } 4478 4479 /** 4480 * ice_remove_vsi_lkup_fltr - Remove lookup type filters for a VSI 4481 * @hw: pointer to the hardware structure 4482 * @vsi_handle: VSI handle to remove filters from 4483 * @lkup: switch rule filter lookup type 4484 */ 4485 static void 4486 ice_remove_vsi_lkup_fltr(struct ice_hw *hw, u16 vsi_handle, 4487 enum ice_sw_lkup_type lkup) 4488 { 4489 struct ice_switch_info *sw = hw->switch_info; 4490 struct ice_fltr_list_entry *fm_entry; 4491 struct list_head remove_list_head; 4492 struct list_head *rule_head; 4493 struct ice_fltr_list_entry *tmp; 4494 struct mutex *rule_lock; /* Lock to protect filter rule list */ 4495 int status; 4496 4497 INIT_LIST_HEAD(&remove_list_head); 4498 rule_lock = &sw->recp_list[lkup].filt_rule_lock; 4499 rule_head = &sw->recp_list[lkup].filt_rules; 4500 mutex_lock(rule_lock); 4501 status = ice_add_to_vsi_fltr_list(hw, vsi_handle, rule_head, 4502 &remove_list_head); 4503 mutex_unlock(rule_lock); 4504 if (status) 4505 goto free_fltr_list; 4506 4507 switch (lkup) { 4508 case ICE_SW_LKUP_MAC: 4509 ice_remove_mac(hw, &remove_list_head); 4510 break; 4511 case ICE_SW_LKUP_VLAN: 4512 ice_remove_vlan(hw, &remove_list_head); 4513 break; 4514 case ICE_SW_LKUP_PROMISC: 4515 case ICE_SW_LKUP_PROMISC_VLAN: 4516 ice_remove_promisc(hw, lkup, &remove_list_head); 4517 break; 4518 case ICE_SW_LKUP_MAC_VLAN: 4519 case ICE_SW_LKUP_ETHERTYPE: 4520 case ICE_SW_LKUP_ETHERTYPE_MAC: 4521 case ICE_SW_LKUP_DFLT: 4522 case ICE_SW_LKUP_LAST: 4523 default: 4524 ice_debug(hw, ICE_DBG_SW, "Unsupported lookup type %d\n", lkup); 4525 break; 4526 } 4527 4528 free_fltr_list: 4529 list_for_each_entry_safe(fm_entry, tmp, &remove_list_head, list_entry) { 4530 list_del(&fm_entry->list_entry); 4531 devm_kfree(ice_hw_to_dev(hw), fm_entry); 4532 } 4533 } 4534 4535 /** 4536 * ice_remove_vsi_fltr - Remove all filters for a VSI 4537 * @hw: pointer to the hardware structure 4538 * @vsi_handle: VSI handle to remove filters from 4539 */ 4540 void ice_remove_vsi_fltr(struct ice_hw *hw, u16 vsi_handle) 4541 { 4542 ice_remove_vsi_lkup_fltr(hw, vsi_handle, ICE_SW_LKUP_MAC); 4543 ice_remove_vsi_lkup_fltr(hw, vsi_handle, ICE_SW_LKUP_MAC_VLAN); 4544 ice_remove_vsi_lkup_fltr(hw, vsi_handle, ICE_SW_LKUP_PROMISC); 4545 ice_remove_vsi_lkup_fltr(hw, vsi_handle, ICE_SW_LKUP_VLAN); 4546 ice_remove_vsi_lkup_fltr(hw, vsi_handle, ICE_SW_LKUP_DFLT); 4547 ice_remove_vsi_lkup_fltr(hw, vsi_handle, ICE_SW_LKUP_ETHERTYPE); 4548 ice_remove_vsi_lkup_fltr(hw, vsi_handle, ICE_SW_LKUP_ETHERTYPE_MAC); 4549 ice_remove_vsi_lkup_fltr(hw, vsi_handle, ICE_SW_LKUP_PROMISC_VLAN); 4550 } 4551 4552 /** 4553 * ice_alloc_res_cntr - allocating resource counter 4554 * @hw: pointer to the hardware structure 4555 * @type: type of resource 4556 * @alloc_shared: if set it is shared else dedicated 4557 * @num_items: number of entries requested for FD resource type 4558 * @counter_id: counter index returned by AQ call 4559 */ 4560 int 4561 ice_alloc_res_cntr(struct ice_hw *hw, u8 type, u8 alloc_shared, u16 num_items, 4562 u16 *counter_id) 4563 { 4564 DEFINE_RAW_FLEX(struct ice_aqc_alloc_free_res_elem, buf, elem, 1); 4565 u16 buf_len = __struct_size(buf); 4566 int status; 4567 4568 buf->num_elems = cpu_to_le16(num_items); 4569 buf->res_type = cpu_to_le16(FIELD_PREP(ICE_AQC_RES_TYPE_M, type) | 4570 alloc_shared); 4571 4572 status = ice_aq_alloc_free_res(hw, buf, buf_len, ice_aqc_opc_alloc_res); 4573 if (status) 4574 return status; 4575 4576 *counter_id = le16_to_cpu(buf->elem[0].e.sw_resp); 4577 return status; 4578 } 4579 4580 /** 4581 * ice_free_res_cntr - free resource counter 4582 * @hw: pointer to the hardware structure 4583 * @type: type of resource 4584 * @alloc_shared: if set it is shared else dedicated 4585 * @num_items: number of entries to be freed for FD resource type 4586 * @counter_id: counter ID resource which needs to be freed 4587 */ 4588 int 4589 ice_free_res_cntr(struct ice_hw *hw, u8 type, u8 alloc_shared, u16 num_items, 4590 u16 counter_id) 4591 { 4592 DEFINE_RAW_FLEX(struct ice_aqc_alloc_free_res_elem, buf, elem, 1); 4593 u16 buf_len = __struct_size(buf); 4594 int status; 4595 4596 buf->num_elems = cpu_to_le16(num_items); 4597 buf->res_type = cpu_to_le16(FIELD_PREP(ICE_AQC_RES_TYPE_M, type) | 4598 alloc_shared); 4599 buf->elem[0].e.sw_resp = cpu_to_le16(counter_id); 4600 4601 status = ice_aq_alloc_free_res(hw, buf, buf_len, ice_aqc_opc_free_res); 4602 if (status) 4603 ice_debug(hw, ICE_DBG_SW, "counter resource could not be freed\n"); 4604 4605 return status; 4606 } 4607 4608 #define ICE_PROTOCOL_ENTRY(id, ...) { \ 4609 .prot_type = id, \ 4610 .offs = {__VA_ARGS__}, \ 4611 } 4612 4613 /** 4614 * ice_share_res - set a resource as shared or dedicated 4615 * @hw: hw struct of original owner of resource 4616 * @type: resource type 4617 * @shared: is the resource being set to shared 4618 * @res_id: resource id (descriptor) 4619 */ 4620 int ice_share_res(struct ice_hw *hw, u16 type, u8 shared, u16 res_id) 4621 { 4622 DEFINE_RAW_FLEX(struct ice_aqc_alloc_free_res_elem, buf, elem, 1); 4623 u16 buf_len = __struct_size(buf); 4624 u16 res_type; 4625 int status; 4626 4627 buf->num_elems = cpu_to_le16(1); 4628 res_type = FIELD_PREP(ICE_AQC_RES_TYPE_M, type); 4629 if (shared) 4630 res_type |= ICE_AQC_RES_TYPE_FLAG_SHARED; 4631 4632 buf->res_type = cpu_to_le16(res_type); 4633 buf->elem[0].e.sw_resp = cpu_to_le16(res_id); 4634 status = ice_aq_alloc_free_res(hw, buf, buf_len, 4635 ice_aqc_opc_share_res); 4636 if (status) 4637 ice_debug(hw, ICE_DBG_SW, "Could not set resource type %u id %u to %s\n", 4638 type, res_id, shared ? "SHARED" : "DEDICATED"); 4639 4640 return status; 4641 } 4642 4643 /* This is mapping table entry that maps every word within a given protocol 4644 * structure to the real byte offset as per the specification of that 4645 * protocol header. 4646 * for example dst address is 3 words in ethertype header and corresponding 4647 * bytes are 0, 2, 3 in the actual packet header and src address is at 4, 6, 8 4648 * IMPORTANT: Every structure part of "ice_prot_hdr" union should have a 4649 * matching entry describing its field. This needs to be updated if new 4650 * structure is added to that union. 4651 */ 4652 static const struct ice_prot_ext_tbl_entry ice_prot_ext[ICE_PROTOCOL_LAST] = { 4653 ICE_PROTOCOL_ENTRY(ICE_MAC_OFOS, 0, 2, 4, 6, 8, 10, 12), 4654 ICE_PROTOCOL_ENTRY(ICE_MAC_IL, 0, 2, 4, 6, 8, 10, 12), 4655 ICE_PROTOCOL_ENTRY(ICE_ETYPE_OL, 0), 4656 ICE_PROTOCOL_ENTRY(ICE_ETYPE_IL, 0), 4657 ICE_PROTOCOL_ENTRY(ICE_VLAN_OFOS, 2, 0), 4658 ICE_PROTOCOL_ENTRY(ICE_IPV4_OFOS, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18), 4659 ICE_PROTOCOL_ENTRY(ICE_IPV4_IL, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18), 4660 ICE_PROTOCOL_ENTRY(ICE_IPV6_OFOS, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 4661 20, 22, 24, 26, 28, 30, 32, 34, 36, 38), 4662 ICE_PROTOCOL_ENTRY(ICE_IPV6_IL, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 4663 22, 24, 26, 28, 30, 32, 34, 36, 38), 4664 ICE_PROTOCOL_ENTRY(ICE_TCP_IL, 0, 2), 4665 ICE_PROTOCOL_ENTRY(ICE_UDP_OF, 0, 2), 4666 ICE_PROTOCOL_ENTRY(ICE_UDP_ILOS, 0, 2), 4667 ICE_PROTOCOL_ENTRY(ICE_VXLAN, 8, 10, 12, 14), 4668 ICE_PROTOCOL_ENTRY(ICE_GENEVE, 8, 10, 12, 14), 4669 ICE_PROTOCOL_ENTRY(ICE_NVGRE, 0, 2, 4, 6), 4670 ICE_PROTOCOL_ENTRY(ICE_GTP, 8, 10, 12, 14, 16, 18, 20, 22), 4671 ICE_PROTOCOL_ENTRY(ICE_GTP_NO_PAY, 8, 10, 12, 14), 4672 ICE_PROTOCOL_ENTRY(ICE_PFCP, 8, 10, 12, 14, 16, 18, 20, 22), 4673 ICE_PROTOCOL_ENTRY(ICE_PPPOE, 0, 2, 4, 6), 4674 ICE_PROTOCOL_ENTRY(ICE_L2TPV3, 0, 2, 4, 6, 8, 10), 4675 ICE_PROTOCOL_ENTRY(ICE_VLAN_EX, 2, 0), 4676 ICE_PROTOCOL_ENTRY(ICE_VLAN_IN, 2, 0), 4677 ICE_PROTOCOL_ENTRY(ICE_HW_METADATA, 4678 ICE_SOURCE_PORT_MDID_OFFSET, 4679 ICE_PTYPE_MDID_OFFSET, 4680 ICE_PACKET_LENGTH_MDID_OFFSET, 4681 ICE_SOURCE_VSI_MDID_OFFSET, 4682 ICE_PKT_VLAN_MDID_OFFSET, 4683 ICE_PKT_TUNNEL_MDID_OFFSET, 4684 ICE_PKT_TCP_MDID_OFFSET, 4685 ICE_PKT_ERROR_MDID_OFFSET), 4686 }; 4687 4688 static struct ice_protocol_entry ice_prot_id_tbl[ICE_PROTOCOL_LAST] = { 4689 { ICE_MAC_OFOS, ICE_MAC_OFOS_HW }, 4690 { ICE_MAC_IL, ICE_MAC_IL_HW }, 4691 { ICE_ETYPE_OL, ICE_ETYPE_OL_HW }, 4692 { ICE_ETYPE_IL, ICE_ETYPE_IL_HW }, 4693 { ICE_VLAN_OFOS, ICE_VLAN_OL_HW }, 4694 { ICE_IPV4_OFOS, ICE_IPV4_OFOS_HW }, 4695 { ICE_IPV4_IL, ICE_IPV4_IL_HW }, 4696 { ICE_IPV6_OFOS, ICE_IPV6_OFOS_HW }, 4697 { ICE_IPV6_IL, ICE_IPV6_IL_HW }, 4698 { ICE_TCP_IL, ICE_TCP_IL_HW }, 4699 { ICE_UDP_OF, ICE_UDP_OF_HW }, 4700 { ICE_UDP_ILOS, ICE_UDP_ILOS_HW }, 4701 { ICE_VXLAN, ICE_UDP_OF_HW }, 4702 { ICE_GENEVE, ICE_UDP_OF_HW }, 4703 { ICE_NVGRE, ICE_GRE_OF_HW }, 4704 { ICE_GTP, ICE_UDP_OF_HW }, 4705 { ICE_GTP_NO_PAY, ICE_UDP_ILOS_HW }, 4706 { ICE_PFCP, ICE_UDP_ILOS_HW }, 4707 { ICE_PPPOE, ICE_PPPOE_HW }, 4708 { ICE_L2TPV3, ICE_L2TPV3_HW }, 4709 { ICE_VLAN_EX, ICE_VLAN_OF_HW }, 4710 { ICE_VLAN_IN, ICE_VLAN_OL_HW }, 4711 { ICE_HW_METADATA, ICE_META_DATA_ID_HW }, 4712 }; 4713 4714 /** 4715 * ice_find_recp - find a recipe 4716 * @hw: pointer to the hardware structure 4717 * @lkup_exts: extension sequence to match 4718 * @rinfo: information regarding the rule e.g. priority and action info 4719 * @is_add: flag of adding recipe 4720 * 4721 * Returns index of matching recipe, or ICE_MAX_NUM_RECIPES if not found. 4722 */ 4723 static u16 4724 ice_find_recp(struct ice_hw *hw, struct ice_prot_lkup_ext *lkup_exts, 4725 const struct ice_adv_rule_info *rinfo, bool is_add) 4726 { 4727 bool refresh_required = true; 4728 struct ice_sw_recipe *recp; 4729 u8 i; 4730 4731 /* Walk through existing recipes to find a match */ 4732 recp = hw->switch_info->recp_list; 4733 for (i = 0; i < ICE_MAX_NUM_RECIPES; i++) { 4734 /* If recipe was not created for this ID, in SW bookkeeping, 4735 * check if FW has an entry for this recipe. If the FW has an 4736 * entry update it in our SW bookkeeping and continue with the 4737 * matching. 4738 */ 4739 if (hw->recp_reuse) { 4740 if (ice_get_recp_frm_fw(hw, 4741 hw->switch_info->recp_list, i, 4742 &refresh_required, is_add)) 4743 continue; 4744 } 4745 4746 /* if number of words we are looking for match */ 4747 if (lkup_exts->n_val_words == recp[i].lkup_exts.n_val_words) { 4748 struct ice_fv_word *ar = recp[i].lkup_exts.fv_words; 4749 struct ice_fv_word *be = lkup_exts->fv_words; 4750 u16 *cr = recp[i].lkup_exts.field_mask; 4751 u16 *de = lkup_exts->field_mask; 4752 bool found = true; 4753 u8 pe, qr; 4754 4755 /* ar, cr, and qr are related to the recipe words, while 4756 * be, de, and pe are related to the lookup words 4757 */ 4758 for (pe = 0; pe < lkup_exts->n_val_words; pe++) { 4759 for (qr = 0; qr < recp[i].lkup_exts.n_val_words; 4760 qr++) { 4761 if (ar[qr].off == be[pe].off && 4762 ar[qr].prot_id == be[pe].prot_id && 4763 cr[qr] == de[pe]) 4764 /* Found the "pe"th word in the 4765 * given recipe 4766 */ 4767 break; 4768 } 4769 /* After walking through all the words in the 4770 * "i"th recipe if "p"th word was not found then 4771 * this recipe is not what we are looking for. 4772 * So break out from this loop and try the next 4773 * recipe 4774 */ 4775 if (qr >= recp[i].lkup_exts.n_val_words) { 4776 found = false; 4777 break; 4778 } 4779 } 4780 /* If for "i"th recipe the found was never set to false 4781 * then it means we found our match 4782 * Also tun type and *_pass_l2 of recipe needs to be 4783 * checked 4784 */ 4785 if (found && recp[i].tun_type == rinfo->tun_type && 4786 recp[i].need_pass_l2 == rinfo->need_pass_l2 && 4787 recp[i].allow_pass_l2 == rinfo->allow_pass_l2 && 4788 recp[i].priority == rinfo->priority) 4789 return i; /* Return the recipe ID */ 4790 } 4791 } 4792 return ICE_MAX_NUM_RECIPES; 4793 } 4794 4795 /** 4796 * ice_change_proto_id_to_dvm - change proto id in prot_id_tbl 4797 * 4798 * As protocol id for outer vlan is different in dvm and svm, if dvm is 4799 * supported protocol array record for outer vlan has to be modified to 4800 * reflect the value proper for DVM. 4801 */ 4802 void ice_change_proto_id_to_dvm(void) 4803 { 4804 u8 i; 4805 4806 for (i = 0; i < ARRAY_SIZE(ice_prot_id_tbl); i++) 4807 if (ice_prot_id_tbl[i].type == ICE_VLAN_OFOS && 4808 ice_prot_id_tbl[i].protocol_id != ICE_VLAN_OF_HW) 4809 ice_prot_id_tbl[i].protocol_id = ICE_VLAN_OF_HW; 4810 } 4811 4812 /** 4813 * ice_prot_type_to_id - get protocol ID from protocol type 4814 * @type: protocol type 4815 * @id: pointer to variable that will receive the ID 4816 * 4817 * Returns true if found, false otherwise 4818 */ 4819 static bool ice_prot_type_to_id(enum ice_protocol_type type, u8 *id) 4820 { 4821 u8 i; 4822 4823 for (i = 0; i < ARRAY_SIZE(ice_prot_id_tbl); i++) 4824 if (ice_prot_id_tbl[i].type == type) { 4825 *id = ice_prot_id_tbl[i].protocol_id; 4826 return true; 4827 } 4828 return false; 4829 } 4830 4831 /** 4832 * ice_fill_valid_words - count valid words 4833 * @rule: advanced rule with lookup information 4834 * @lkup_exts: byte offset extractions of the words that are valid 4835 * 4836 * calculate valid words in a lookup rule using mask value 4837 */ 4838 static u8 4839 ice_fill_valid_words(struct ice_adv_lkup_elem *rule, 4840 struct ice_prot_lkup_ext *lkup_exts) 4841 { 4842 u8 j, word, prot_id, ret_val; 4843 4844 if (!ice_prot_type_to_id(rule->type, &prot_id)) 4845 return 0; 4846 4847 word = lkup_exts->n_val_words; 4848 4849 for (j = 0; j < sizeof(rule->m_u) / sizeof(u16); j++) 4850 if (((u16 *)&rule->m_u)[j] && 4851 rule->type < ARRAY_SIZE(ice_prot_ext)) { 4852 /* No more space to accommodate */ 4853 if (word >= ICE_MAX_CHAIN_WORDS) 4854 return 0; 4855 lkup_exts->fv_words[word].off = 4856 ice_prot_ext[rule->type].offs[j]; 4857 lkup_exts->fv_words[word].prot_id = 4858 ice_prot_id_tbl[rule->type].protocol_id; 4859 lkup_exts->field_mask[word] = 4860 be16_to_cpu(((__force __be16 *)&rule->m_u)[j]); 4861 word++; 4862 } 4863 4864 ret_val = word - lkup_exts->n_val_words; 4865 lkup_exts->n_val_words = word; 4866 4867 return ret_val; 4868 } 4869 4870 /** 4871 * ice_fill_fv_word_index - fill in the field vector indices for a recipe group 4872 * @hw: pointer to the hardware structure 4873 * @rm: recipe management list entry 4874 * 4875 * Helper function to fill in the field vector indices for protocol-offset 4876 * pairs. These indexes are then ultimately programmed into a recipe. 4877 */ 4878 static int 4879 ice_fill_fv_word_index(struct ice_hw *hw, struct ice_sw_recipe *rm) 4880 { 4881 struct ice_sw_fv_list_entry *fv; 4882 struct ice_fv_word *fv_ext; 4883 u8 i; 4884 4885 if (list_empty(&rm->fv_list)) 4886 return -EINVAL; 4887 4888 fv = list_first_entry(&rm->fv_list, struct ice_sw_fv_list_entry, 4889 list_entry); 4890 fv_ext = fv->fv_ptr->ew; 4891 4892 /* Add switch id as the first word. */ 4893 rm->fv_idx[0] = ICE_AQ_SW_ID_LKUP_IDX; 4894 rm->fv_mask[0] = ICE_AQ_SW_ID_LKUP_MASK; 4895 rm->n_ext_words++; 4896 4897 for (i = 1; i < rm->n_ext_words; i++) { 4898 struct ice_fv_word *fv_word = &rm->ext_words[i - 1]; 4899 u16 fv_mask = rm->word_masks[i - 1]; 4900 bool found = false; 4901 u8 j; 4902 4903 for (j = 0; j < hw->blk[ICE_BLK_SW].es.fvw; j++) { 4904 if (fv_ext[j].prot_id == fv_word->prot_id && 4905 fv_ext[j].off == fv_word->off) { 4906 found = true; 4907 4908 /* Store index of field vector */ 4909 rm->fv_idx[i] = j; 4910 rm->fv_mask[i] = fv_mask; 4911 break; 4912 } 4913 } 4914 4915 /* Protocol/offset could not be found, caller gave an invalid 4916 * pair. 4917 */ 4918 if (!found) 4919 return -EINVAL; 4920 } 4921 4922 return 0; 4923 } 4924 4925 /** 4926 * ice_find_free_recp_res_idx - find free result indexes for recipe 4927 * @hw: pointer to hardware structure 4928 * @profiles: bitmap of profiles that will be associated with the new recipe 4929 * @free_idx: pointer to variable to receive the free index bitmap 4930 * 4931 * The algorithm used here is: 4932 * 1. When creating a new recipe, create a set P which contains all 4933 * Profiles that will be associated with our new recipe 4934 * 4935 * 2. For each Profile p in set P: 4936 * a. Add all recipes associated with Profile p into set R 4937 * b. Optional : PossibleIndexes &= profile[p].possibleIndexes 4938 * [initially PossibleIndexes should be 0xFFFFFFFFFFFFFFFF] 4939 * i. Or just assume they all have the same possible indexes: 4940 * 44, 45, 46, 47 4941 * i.e., PossibleIndexes = 0x0000F00000000000 4942 * 4943 * 3. For each Recipe r in set R: 4944 * a. UsedIndexes |= (bitwise or ) recipe[r].res_indexes 4945 * b. FreeIndexes = UsedIndexes ^ PossibleIndexes 4946 * 4947 * FreeIndexes will contain the bits indicating the indexes free for use, 4948 * then the code needs to update the recipe[r].used_result_idx_bits to 4949 * indicate which indexes were selected for use by this recipe. 4950 */ 4951 static u16 4952 ice_find_free_recp_res_idx(struct ice_hw *hw, const unsigned long *profiles, 4953 unsigned long *free_idx) 4954 { 4955 DECLARE_BITMAP(possible_idx, ICE_MAX_FV_WORDS); 4956 DECLARE_BITMAP(recipes, ICE_MAX_NUM_RECIPES); 4957 DECLARE_BITMAP(used_idx, ICE_MAX_FV_WORDS); 4958 u16 bit; 4959 4960 bitmap_zero(recipes, ICE_MAX_NUM_RECIPES); 4961 bitmap_zero(used_idx, ICE_MAX_FV_WORDS); 4962 4963 bitmap_fill(possible_idx, ICE_MAX_FV_WORDS); 4964 4965 /* For each profile we are going to associate the recipe with, add the 4966 * recipes that are associated with that profile. This will give us 4967 * the set of recipes that our recipe may collide with. Also, determine 4968 * what possible result indexes are usable given this set of profiles. 4969 */ 4970 for_each_set_bit(bit, profiles, ICE_MAX_NUM_PROFILES) { 4971 bitmap_or(recipes, recipes, profile_to_recipe[bit], 4972 ICE_MAX_NUM_RECIPES); 4973 bitmap_and(possible_idx, possible_idx, 4974 hw->switch_info->prof_res_bm[bit], 4975 ICE_MAX_FV_WORDS); 4976 } 4977 4978 /* For each recipe that our new recipe may collide with, determine 4979 * which indexes have been used. 4980 */ 4981 for_each_set_bit(bit, recipes, ICE_MAX_NUM_RECIPES) 4982 bitmap_or(used_idx, used_idx, 4983 hw->switch_info->recp_list[bit].res_idxs, 4984 ICE_MAX_FV_WORDS); 4985 4986 bitmap_xor(free_idx, used_idx, possible_idx, ICE_MAX_FV_WORDS); 4987 4988 /* return number of free indexes */ 4989 return (u16)bitmap_weight(free_idx, ICE_MAX_FV_WORDS); 4990 } 4991 4992 /** 4993 * ice_calc_recp_cnt - calculate number of recipes based on word count 4994 * @word_cnt: number of lookup words 4995 * 4996 * Word count should include switch ID word and regular lookup words. 4997 * Returns: number of recipes required to fit @word_cnt, including extra recipes 4998 * needed for recipe chaining (if needed). 4999 */ 5000 static int ice_calc_recp_cnt(u8 word_cnt) 5001 { 5002 /* All words fit in a single recipe, no need for chaining. */ 5003 if (word_cnt <= ICE_NUM_WORDS_RECIPE) 5004 return 1; 5005 5006 /* Recipe chaining required. Result indexes are fitted right after 5007 * regular lookup words. In some cases a new recipe must be added in 5008 * order to fit result indexes. 5009 * 5010 * While the word count increases, every 5 words an extra recipe needs 5011 * to be added. However, by adding a recipe, one word for its result 5012 * index must also be added, therefore every 4 words recipe count 5013 * increases by 1. This calculation does not apply to word count == 1, 5014 * which is handled above. 5015 */ 5016 return (word_cnt + 2) / (ICE_NUM_WORDS_RECIPE - 1); 5017 } 5018 5019 static void fill_recipe_template(struct ice_aqc_recipe_data_elem *recp, u16 rid, 5020 const struct ice_sw_recipe *rm) 5021 { 5022 int i; 5023 5024 recp->recipe_indx = rid; 5025 recp->content.act_ctrl |= ICE_AQ_RECIPE_ACT_PRUNE_INDX_M; 5026 5027 for (i = 0; i < ICE_NUM_WORDS_RECIPE; i++) { 5028 recp->content.lkup_indx[i] = ICE_AQ_RECIPE_LKUP_IGNORE; 5029 recp->content.mask[i] = cpu_to_le16(0); 5030 } 5031 5032 set_bit(rid, (unsigned long *)recp->recipe_bitmap); 5033 recp->content.act_ctrl_fwd_priority = rm->priority; 5034 5035 if (rm->need_pass_l2) 5036 recp->content.act_ctrl |= ICE_AQ_RECIPE_ACT_NEED_PASS_L2; 5037 5038 if (rm->allow_pass_l2) 5039 recp->content.act_ctrl |= ICE_AQ_RECIPE_ACT_ALLOW_PASS_L2; 5040 } 5041 5042 static void bookkeep_recipe(struct ice_sw_recipe *recipe, 5043 struct ice_aqc_recipe_data_elem *r, 5044 const struct ice_sw_recipe *rm) 5045 { 5046 memcpy(recipe->r_bitmap, r->recipe_bitmap, sizeof(recipe->r_bitmap)); 5047 5048 recipe->priority = r->content.act_ctrl_fwd_priority; 5049 recipe->tun_type = rm->tun_type; 5050 recipe->need_pass_l2 = rm->need_pass_l2; 5051 recipe->allow_pass_l2 = rm->allow_pass_l2; 5052 recipe->recp_created = true; 5053 } 5054 5055 /* For memcpy in ice_add_sw_recipe. */ 5056 static_assert(sizeof_field(struct ice_aqc_recipe_data_elem, recipe_bitmap) == 5057 sizeof_field(struct ice_sw_recipe, r_bitmap)); 5058 5059 /** 5060 * ice_add_sw_recipe - function to call AQ calls to create switch recipe 5061 * @hw: pointer to hardware structure 5062 * @rm: recipe management list entry 5063 * @profiles: bitmap of profiles that will be associated. 5064 */ 5065 static int 5066 ice_add_sw_recipe(struct ice_hw *hw, struct ice_sw_recipe *rm, 5067 unsigned long *profiles) 5068 { 5069 struct ice_aqc_recipe_data_elem *buf __free(kfree) = NULL; 5070 DECLARE_BITMAP(result_idx_bm, ICE_MAX_FV_WORDS); 5071 struct ice_aqc_recipe_data_elem *root; 5072 struct ice_sw_recipe *recipe; 5073 u16 free_res_idx, rid; 5074 int lookup = 0; 5075 int recp_cnt; 5076 int status; 5077 int word; 5078 int i; 5079 5080 recp_cnt = ice_calc_recp_cnt(rm->n_ext_words); 5081 5082 bitmap_zero(result_idx_bm, ICE_MAX_FV_WORDS); 5083 bitmap_zero(rm->r_bitmap, ICE_MAX_NUM_RECIPES); 5084 5085 /* Check number of free result indices */ 5086 free_res_idx = ice_find_free_recp_res_idx(hw, profiles, result_idx_bm); 5087 5088 ice_debug(hw, ICE_DBG_SW, "Result idx slots: %d, need %d\n", 5089 free_res_idx, recp_cnt); 5090 5091 /* Last recipe doesn't need result index */ 5092 if (recp_cnt - 1 > free_res_idx) 5093 return -ENOSPC; 5094 5095 if (recp_cnt > ICE_MAX_CHAIN_RECIPE_RES) 5096 return -E2BIG; 5097 5098 buf = kcalloc(recp_cnt, sizeof(*buf), GFP_KERNEL); 5099 if (!buf) 5100 return -ENOMEM; 5101 5102 /* Setup the non-root subrecipes. These do not contain lookups for other 5103 * subrecipes results. Set associated recipe only to own recipe index. 5104 * Each non-root subrecipe needs a free result index from FV. 5105 * 5106 * Note: only done if there is more than one recipe. 5107 */ 5108 for (i = 0; i < recp_cnt - 1; i++) { 5109 struct ice_aqc_recipe_content *content; 5110 u8 result_idx; 5111 5112 status = ice_alloc_recipe(hw, &rid); 5113 if (status) 5114 return status; 5115 5116 fill_recipe_template(&buf[i], rid, rm); 5117 5118 result_idx = find_first_bit(result_idx_bm, ICE_MAX_FV_WORDS); 5119 /* Check if there really is a valid result index that can be 5120 * used. 5121 */ 5122 if (result_idx >= ICE_MAX_FV_WORDS) { 5123 ice_debug(hw, ICE_DBG_SW, "No chain index available\n"); 5124 return -ENOSPC; 5125 } 5126 clear_bit(result_idx, result_idx_bm); 5127 5128 content = &buf[i].content; 5129 content->result_indx = ICE_AQ_RECIPE_RESULT_EN | 5130 FIELD_PREP(ICE_AQ_RECIPE_RESULT_DATA_M, 5131 result_idx); 5132 5133 /* Set recipe association to be used for root recipe */ 5134 set_bit(rid, rm->r_bitmap); 5135 5136 word = 0; 5137 while (lookup < rm->n_ext_words && 5138 word < ICE_NUM_WORDS_RECIPE) { 5139 content->lkup_indx[word] = rm->fv_idx[lookup]; 5140 content->mask[word] = cpu_to_le16(rm->fv_mask[lookup]); 5141 5142 lookup++; 5143 word++; 5144 } 5145 5146 recipe = &hw->switch_info->recp_list[rid]; 5147 set_bit(result_idx, recipe->res_idxs); 5148 bookkeep_recipe(recipe, &buf[i], rm); 5149 } 5150 5151 /* Setup the root recipe */ 5152 status = ice_alloc_recipe(hw, &rid); 5153 if (status) 5154 return status; 5155 5156 recipe = &hw->switch_info->recp_list[rid]; 5157 root = &buf[recp_cnt - 1]; 5158 fill_recipe_template(root, rid, rm); 5159 5160 /* Set recipe association, use previously set bitmap and own rid */ 5161 set_bit(rid, rm->r_bitmap); 5162 memcpy(root->recipe_bitmap, rm->r_bitmap, sizeof(root->recipe_bitmap)); 5163 5164 /* For non-root recipes rid should be 0, for root it should be correct 5165 * rid value ored with 0x80 (is root bit). 5166 */ 5167 root->content.rid = rid | ICE_AQ_RECIPE_ID_IS_ROOT; 5168 5169 /* Fill remaining lookups in root recipe */ 5170 word = 0; 5171 while (lookup < rm->n_ext_words && 5172 word < ICE_NUM_WORDS_RECIPE /* should always be true */) { 5173 root->content.lkup_indx[word] = rm->fv_idx[lookup]; 5174 root->content.mask[word] = cpu_to_le16(rm->fv_mask[lookup]); 5175 5176 lookup++; 5177 word++; 5178 } 5179 5180 /* Fill result indexes as lookups */ 5181 i = 0; 5182 while (i < recp_cnt - 1 && 5183 word < ICE_NUM_WORDS_RECIPE /* should always be true */) { 5184 root->content.lkup_indx[word] = buf[i].content.result_indx & 5185 ~ICE_AQ_RECIPE_RESULT_EN; 5186 root->content.mask[word] = cpu_to_le16(0xffff); 5187 /* For bookkeeping, it is needed to mark FV index as used for 5188 * intermediate result. 5189 */ 5190 set_bit(root->content.lkup_indx[word], recipe->res_idxs); 5191 5192 i++; 5193 word++; 5194 } 5195 5196 rm->root_rid = rid; 5197 bookkeep_recipe(&hw->switch_info->recp_list[rid], root, rm); 5198 5199 /* Program the recipe */ 5200 status = ice_acquire_change_lock(hw, ICE_RES_WRITE); 5201 if (status) 5202 return status; 5203 5204 status = ice_aq_add_recipe(hw, buf, recp_cnt, NULL); 5205 ice_release_change_lock(hw); 5206 if (status) 5207 return status; 5208 5209 return 0; 5210 } 5211 5212 /* ice_get_compat_fv_bitmap - Get compatible field vector bitmap for rule 5213 * @hw: pointer to hardware structure 5214 * @rinfo: other information regarding the rule e.g. priority and action info 5215 * @bm: pointer to memory for returning the bitmap of field vectors 5216 */ 5217 static void 5218 ice_get_compat_fv_bitmap(struct ice_hw *hw, struct ice_adv_rule_info *rinfo, 5219 unsigned long *bm) 5220 { 5221 enum ice_prof_type prof_type; 5222 5223 bitmap_zero(bm, ICE_MAX_NUM_PROFILES); 5224 5225 switch (rinfo->tun_type) { 5226 case ICE_NON_TUN: 5227 prof_type = ICE_PROF_NON_TUN; 5228 break; 5229 case ICE_ALL_TUNNELS: 5230 prof_type = ICE_PROF_TUN_ALL; 5231 break; 5232 case ICE_SW_TUN_GENEVE: 5233 case ICE_SW_TUN_VXLAN: 5234 prof_type = ICE_PROF_TUN_UDP; 5235 break; 5236 case ICE_SW_TUN_NVGRE: 5237 prof_type = ICE_PROF_TUN_GRE; 5238 break; 5239 case ICE_SW_TUN_GTPU: 5240 prof_type = ICE_PROF_TUN_GTPU; 5241 break; 5242 case ICE_SW_TUN_GTPC: 5243 prof_type = ICE_PROF_TUN_GTPC; 5244 break; 5245 case ICE_SW_TUN_PFCP: 5246 prof_type = ICE_PROF_TUN_PFCP; 5247 break; 5248 case ICE_SW_TUN_AND_NON_TUN: 5249 default: 5250 prof_type = ICE_PROF_ALL; 5251 break; 5252 } 5253 5254 ice_get_sw_fv_bitmap(hw, prof_type, bm); 5255 } 5256 5257 /** 5258 * ice_subscribe_recipe - subscribe to an existing recipe 5259 * @hw: pointer to the hardware structure 5260 * @rid: recipe ID to subscribe to 5261 * 5262 * Return: 0 on success, and others on error 5263 */ 5264 static int ice_subscribe_recipe(struct ice_hw *hw, u16 rid) 5265 { 5266 DEFINE_RAW_FLEX(struct ice_aqc_alloc_free_res_elem, sw_buf, elem, 1); 5267 u16 buf_len = __struct_size(sw_buf); 5268 u16 res_type; 5269 int status; 5270 5271 /* Prepare buffer to allocate resource */ 5272 sw_buf->num_elems = cpu_to_le16(1); 5273 res_type = FIELD_PREP(ICE_AQC_RES_TYPE_M, ICE_AQC_RES_TYPE_RECIPE) | 5274 ICE_AQC_RES_TYPE_FLAG_SUBSCRIBE_SHARED | 5275 ICE_AQC_RES_TYPE_FLAG_SUBSCRIBE_CTL; 5276 sw_buf->res_type = cpu_to_le16(res_type); 5277 5278 sw_buf->elem[0].e.sw_resp = cpu_to_le16(rid); 5279 5280 status = ice_aq_alloc_free_res(hw, sw_buf, buf_len, 5281 ice_aqc_opc_alloc_res); 5282 5283 return status; 5284 } 5285 5286 /** 5287 * ice_subscribable_recp_shared - share an existing subscribable recipe 5288 * @hw: pointer to the hardware structure 5289 * @rid: recipe ID to subscribe to 5290 */ 5291 static void ice_subscribable_recp_shared(struct ice_hw *hw, u16 rid) 5292 { 5293 struct ice_sw_recipe *recps = hw->switch_info->recp_list; 5294 u16 sub_rid; 5295 5296 for_each_set_bit(sub_rid, recps[rid].r_bitmap, ICE_MAX_NUM_RECIPES) 5297 ice_subscribe_recipe(hw, sub_rid); 5298 } 5299 5300 /** 5301 * ice_add_adv_recipe - Add an advanced recipe that is not part of the default 5302 * @hw: pointer to hardware structure 5303 * @lkups: lookup elements or match criteria for the advanced recipe, one 5304 * structure per protocol header 5305 * @lkups_cnt: number of protocols 5306 * @rinfo: other information regarding the rule e.g. priority and action info 5307 * @rid: return the recipe ID of the recipe created 5308 */ 5309 static int 5310 ice_add_adv_recipe(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, 5311 u16 lkups_cnt, struct ice_adv_rule_info *rinfo, u16 *rid) 5312 { 5313 DECLARE_BITMAP(fv_bitmap, ICE_MAX_NUM_PROFILES); 5314 DECLARE_BITMAP(profiles, ICE_MAX_NUM_PROFILES); 5315 struct ice_prot_lkup_ext *lkup_exts; 5316 struct ice_sw_fv_list_entry *fvit; 5317 struct ice_sw_fv_list_entry *tmp; 5318 struct ice_sw_recipe *rm; 5319 int status = 0; 5320 u16 rid_tmp; 5321 u8 i; 5322 5323 if (!lkups_cnt) 5324 return -EINVAL; 5325 5326 lkup_exts = kzalloc(sizeof(*lkup_exts), GFP_KERNEL); 5327 if (!lkup_exts) 5328 return -ENOMEM; 5329 5330 /* Determine the number of words to be matched and if it exceeds a 5331 * recipe's restrictions 5332 */ 5333 for (i = 0; i < lkups_cnt; i++) { 5334 u16 count; 5335 5336 if (lkups[i].type >= ICE_PROTOCOL_LAST) { 5337 status = -EIO; 5338 goto err_free_lkup_exts; 5339 } 5340 5341 count = ice_fill_valid_words(&lkups[i], lkup_exts); 5342 if (!count) { 5343 status = -EIO; 5344 goto err_free_lkup_exts; 5345 } 5346 } 5347 5348 rm = kzalloc(sizeof(*rm), GFP_KERNEL); 5349 if (!rm) { 5350 status = -ENOMEM; 5351 goto err_free_lkup_exts; 5352 } 5353 5354 /* Get field vectors that contain fields extracted from all the protocol 5355 * headers being programmed. 5356 */ 5357 INIT_LIST_HEAD(&rm->fv_list); 5358 5359 /* Get bitmap of field vectors (profiles) that are compatible with the 5360 * rule request; only these will be searched in the subsequent call to 5361 * ice_get_sw_fv_list. 5362 */ 5363 ice_get_compat_fv_bitmap(hw, rinfo, fv_bitmap); 5364 5365 status = ice_get_sw_fv_list(hw, lkup_exts, fv_bitmap, &rm->fv_list); 5366 if (status) 5367 goto err_unroll; 5368 5369 /* Copy FV words and masks from lkup_exts to recipe struct. */ 5370 rm->n_ext_words = lkup_exts->n_val_words; 5371 memcpy(rm->ext_words, lkup_exts->fv_words, sizeof(rm->ext_words)); 5372 memcpy(rm->word_masks, lkup_exts->field_mask, sizeof(rm->word_masks)); 5373 5374 /* set the recipe priority if specified */ 5375 rm->priority = (u8)rinfo->priority; 5376 5377 rm->need_pass_l2 = rinfo->need_pass_l2; 5378 rm->allow_pass_l2 = rinfo->allow_pass_l2; 5379 5380 /* Find offsets from the field vector. Pick the first one for all the 5381 * recipes. 5382 */ 5383 status = ice_fill_fv_word_index(hw, rm); 5384 if (status) 5385 goto err_unroll; 5386 5387 /* get bitmap of all profiles the recipe will be associated with */ 5388 bitmap_zero(profiles, ICE_MAX_NUM_PROFILES); 5389 list_for_each_entry(fvit, &rm->fv_list, list_entry) { 5390 ice_debug(hw, ICE_DBG_SW, "profile: %d\n", fvit->profile_id); 5391 set_bit((u16)fvit->profile_id, profiles); 5392 } 5393 5394 /* Look for a recipe which matches our requested fv / mask list */ 5395 *rid = ice_find_recp(hw, lkup_exts, rinfo, true); 5396 if (*rid < ICE_MAX_NUM_RECIPES) { 5397 /* Success if found a recipe that match the existing criteria */ 5398 if (hw->recp_reuse) 5399 ice_subscribable_recp_shared(hw, *rid); 5400 5401 goto err_unroll; 5402 } 5403 5404 rm->tun_type = rinfo->tun_type; 5405 /* Recipe we need does not exist, add a recipe */ 5406 status = ice_add_sw_recipe(hw, rm, profiles); 5407 if (status) 5408 goto err_unroll; 5409 5410 /* Associate all the recipes created with all the profiles in the 5411 * common field vector. 5412 */ 5413 list_for_each_entry(fvit, &rm->fv_list, list_entry) { 5414 DECLARE_BITMAP(r_bitmap, ICE_MAX_NUM_RECIPES); 5415 u64 recp_assoc; 5416 u16 j; 5417 5418 status = ice_aq_get_recipe_to_profile(hw, fvit->profile_id, 5419 &recp_assoc, NULL); 5420 if (status) 5421 goto err_free_recipe; 5422 5423 bitmap_from_arr64(r_bitmap, &recp_assoc, ICE_MAX_NUM_RECIPES); 5424 bitmap_or(r_bitmap, r_bitmap, rm->r_bitmap, 5425 ICE_MAX_NUM_RECIPES); 5426 status = ice_acquire_change_lock(hw, ICE_RES_WRITE); 5427 if (status) 5428 goto err_free_recipe; 5429 5430 bitmap_to_arr64(&recp_assoc, r_bitmap, ICE_MAX_NUM_RECIPES); 5431 status = ice_aq_map_recipe_to_profile(hw, fvit->profile_id, 5432 recp_assoc, NULL); 5433 ice_release_change_lock(hw); 5434 5435 if (status) 5436 goto err_free_recipe; 5437 5438 /* Update profile to recipe bitmap array */ 5439 bitmap_copy(profile_to_recipe[fvit->profile_id], r_bitmap, 5440 ICE_MAX_NUM_RECIPES); 5441 5442 /* Update recipe to profile bitmap array */ 5443 for_each_set_bit(j, rm->r_bitmap, ICE_MAX_NUM_RECIPES) 5444 set_bit((u16)fvit->profile_id, recipe_to_profile[j]); 5445 } 5446 5447 *rid = rm->root_rid; 5448 memcpy(&hw->switch_info->recp_list[*rid].lkup_exts, lkup_exts, 5449 sizeof(*lkup_exts)); 5450 goto err_unroll; 5451 5452 err_free_recipe: 5453 if (hw->recp_reuse) { 5454 for_each_set_bit(rid_tmp, rm->r_bitmap, ICE_MAX_NUM_RECIPES) { 5455 if (!ice_free_recipe_res(hw, rid_tmp)) 5456 clear_bit(rid_tmp, rm->r_bitmap); 5457 } 5458 } 5459 5460 err_unroll: 5461 list_for_each_entry_safe(fvit, tmp, &rm->fv_list, list_entry) { 5462 list_del(&fvit->list_entry); 5463 devm_kfree(ice_hw_to_dev(hw), fvit); 5464 } 5465 5466 kfree(rm); 5467 5468 err_free_lkup_exts: 5469 kfree(lkup_exts); 5470 5471 return status; 5472 } 5473 5474 /** 5475 * ice_dummy_packet_add_vlan - insert VLAN header to dummy pkt 5476 * 5477 * @dummy_pkt: dummy packet profile pattern to which VLAN tag(s) will be added 5478 * @num_vlan: number of VLAN tags 5479 */ 5480 static struct ice_dummy_pkt_profile * 5481 ice_dummy_packet_add_vlan(const struct ice_dummy_pkt_profile *dummy_pkt, 5482 u32 num_vlan) 5483 { 5484 struct ice_dummy_pkt_profile *profile; 5485 struct ice_dummy_pkt_offsets *offsets; 5486 u32 buf_len, off, etype_off, i; 5487 u8 *pkt; 5488 5489 if (num_vlan < 1 || num_vlan > 2) 5490 return ERR_PTR(-EINVAL); 5491 5492 off = num_vlan * VLAN_HLEN; 5493 5494 buf_len = array_size(num_vlan, sizeof(ice_dummy_vlan_packet_offsets)) + 5495 dummy_pkt->offsets_len; 5496 offsets = kzalloc(buf_len, GFP_KERNEL); 5497 if (!offsets) 5498 return ERR_PTR(-ENOMEM); 5499 5500 offsets[0] = dummy_pkt->offsets[0]; 5501 if (num_vlan == 2) { 5502 offsets[1] = ice_dummy_qinq_packet_offsets[0]; 5503 offsets[2] = ice_dummy_qinq_packet_offsets[1]; 5504 } else if (num_vlan == 1) { 5505 offsets[1] = ice_dummy_vlan_packet_offsets[0]; 5506 } 5507 5508 for (i = 1; dummy_pkt->offsets[i].type != ICE_PROTOCOL_LAST; i++) { 5509 offsets[i + num_vlan].type = dummy_pkt->offsets[i].type; 5510 offsets[i + num_vlan].offset = 5511 dummy_pkt->offsets[i].offset + off; 5512 } 5513 offsets[i + num_vlan] = dummy_pkt->offsets[i]; 5514 5515 etype_off = dummy_pkt->offsets[1].offset; 5516 5517 buf_len = array_size(num_vlan, sizeof(ice_dummy_vlan_packet)) + 5518 dummy_pkt->pkt_len; 5519 pkt = kzalloc(buf_len, GFP_KERNEL); 5520 if (!pkt) { 5521 kfree(offsets); 5522 return ERR_PTR(-ENOMEM); 5523 } 5524 5525 memcpy(pkt, dummy_pkt->pkt, etype_off); 5526 memcpy(pkt + etype_off, 5527 num_vlan == 2 ? ice_dummy_qinq_packet : ice_dummy_vlan_packet, 5528 off); 5529 memcpy(pkt + etype_off + off, dummy_pkt->pkt + etype_off, 5530 dummy_pkt->pkt_len - etype_off); 5531 5532 profile = kzalloc(sizeof(*profile), GFP_KERNEL); 5533 if (!profile) { 5534 kfree(offsets); 5535 kfree(pkt); 5536 return ERR_PTR(-ENOMEM); 5537 } 5538 5539 profile->offsets = offsets; 5540 profile->pkt = pkt; 5541 profile->pkt_len = buf_len; 5542 profile->match |= ICE_PKT_KMALLOC; 5543 5544 return profile; 5545 } 5546 5547 /** 5548 * ice_find_dummy_packet - find dummy packet 5549 * 5550 * @lkups: lookup elements or match criteria for the advanced recipe, one 5551 * structure per protocol header 5552 * @lkups_cnt: number of protocols 5553 * @tun_type: tunnel type 5554 * 5555 * Returns the &ice_dummy_pkt_profile corresponding to these lookup params. 5556 */ 5557 static const struct ice_dummy_pkt_profile * 5558 ice_find_dummy_packet(struct ice_adv_lkup_elem *lkups, u16 lkups_cnt, 5559 enum ice_sw_tunnel_type tun_type) 5560 { 5561 const struct ice_dummy_pkt_profile *ret = ice_dummy_pkt_profiles; 5562 u32 match = 0, vlan_count = 0; 5563 u16 i; 5564 5565 switch (tun_type) { 5566 case ICE_SW_TUN_GTPC: 5567 match |= ICE_PKT_TUN_GTPC; 5568 break; 5569 case ICE_SW_TUN_GTPU: 5570 match |= ICE_PKT_TUN_GTPU; 5571 break; 5572 case ICE_SW_TUN_NVGRE: 5573 match |= ICE_PKT_TUN_NVGRE; 5574 break; 5575 case ICE_SW_TUN_GENEVE: 5576 case ICE_SW_TUN_VXLAN: 5577 match |= ICE_PKT_TUN_UDP; 5578 break; 5579 case ICE_SW_TUN_PFCP: 5580 match |= ICE_PKT_PFCP; 5581 break; 5582 default: 5583 break; 5584 } 5585 5586 for (i = 0; i < lkups_cnt; i++) { 5587 if (lkups[i].type == ICE_UDP_ILOS) 5588 match |= ICE_PKT_INNER_UDP; 5589 else if (lkups[i].type == ICE_TCP_IL) 5590 match |= ICE_PKT_INNER_TCP; 5591 else if (lkups[i].type == ICE_IPV6_OFOS) 5592 match |= ICE_PKT_OUTER_IPV6; 5593 else if (lkups[i].type == ICE_VLAN_OFOS || 5594 lkups[i].type == ICE_VLAN_EX) 5595 vlan_count++; 5596 else if (lkups[i].type == ICE_VLAN_IN) 5597 vlan_count++; 5598 else if (lkups[i].type == ICE_ETYPE_OL && 5599 lkups[i].h_u.ethertype.ethtype_id == 5600 cpu_to_be16(ICE_IPV6_ETHER_ID) && 5601 lkups[i].m_u.ethertype.ethtype_id == 5602 cpu_to_be16(0xFFFF)) 5603 match |= ICE_PKT_OUTER_IPV6; 5604 else if (lkups[i].type == ICE_ETYPE_IL && 5605 lkups[i].h_u.ethertype.ethtype_id == 5606 cpu_to_be16(ICE_IPV6_ETHER_ID) && 5607 lkups[i].m_u.ethertype.ethtype_id == 5608 cpu_to_be16(0xFFFF)) 5609 match |= ICE_PKT_INNER_IPV6; 5610 else if (lkups[i].type == ICE_IPV6_IL) 5611 match |= ICE_PKT_INNER_IPV6; 5612 else if (lkups[i].type == ICE_GTP_NO_PAY) 5613 match |= ICE_PKT_GTP_NOPAY; 5614 else if (lkups[i].type == ICE_PPPOE) { 5615 match |= ICE_PKT_PPPOE; 5616 if (lkups[i].h_u.pppoe_hdr.ppp_prot_id == 5617 htons(PPP_IPV6)) 5618 match |= ICE_PKT_OUTER_IPV6; 5619 } else if (lkups[i].type == ICE_L2TPV3) 5620 match |= ICE_PKT_L2TPV3; 5621 } 5622 5623 while (ret->match && (match & ret->match) != ret->match) 5624 ret++; 5625 5626 if (vlan_count != 0) 5627 ret = ice_dummy_packet_add_vlan(ret, vlan_count); 5628 5629 return ret; 5630 } 5631 5632 /** 5633 * ice_fill_adv_dummy_packet - fill a dummy packet with given match criteria 5634 * 5635 * @lkups: lookup elements or match criteria for the advanced recipe, one 5636 * structure per protocol header 5637 * @lkups_cnt: number of protocols 5638 * @s_rule: stores rule information from the match criteria 5639 * @profile: dummy packet profile (the template, its size and header offsets) 5640 */ 5641 static int 5642 ice_fill_adv_dummy_packet(struct ice_adv_lkup_elem *lkups, u16 lkups_cnt, 5643 struct ice_sw_rule_lkup_rx_tx *s_rule, 5644 const struct ice_dummy_pkt_profile *profile) 5645 { 5646 u8 *pkt; 5647 u16 i; 5648 5649 /* Start with a packet with a pre-defined/dummy content. Then, fill 5650 * in the header values to be looked up or matched. 5651 */ 5652 pkt = s_rule->hdr_data; 5653 5654 memcpy(pkt, profile->pkt, profile->pkt_len); 5655 5656 for (i = 0; i < lkups_cnt; i++) { 5657 const struct ice_dummy_pkt_offsets *offsets = profile->offsets; 5658 enum ice_protocol_type type; 5659 u16 offset = 0, len = 0, j; 5660 bool found = false; 5661 5662 /* find the start of this layer; it should be found since this 5663 * was already checked when search for the dummy packet 5664 */ 5665 type = lkups[i].type; 5666 /* metadata isn't present in the packet */ 5667 if (type == ICE_HW_METADATA) 5668 continue; 5669 5670 for (j = 0; offsets[j].type != ICE_PROTOCOL_LAST; j++) { 5671 if (type == offsets[j].type) { 5672 offset = offsets[j].offset; 5673 found = true; 5674 break; 5675 } 5676 } 5677 /* this should never happen in a correct calling sequence */ 5678 if (!found) 5679 return -EINVAL; 5680 5681 switch (lkups[i].type) { 5682 case ICE_MAC_OFOS: 5683 case ICE_MAC_IL: 5684 len = sizeof(struct ice_ether_hdr); 5685 break; 5686 case ICE_ETYPE_OL: 5687 case ICE_ETYPE_IL: 5688 len = sizeof(struct ice_ethtype_hdr); 5689 break; 5690 case ICE_VLAN_OFOS: 5691 case ICE_VLAN_EX: 5692 case ICE_VLAN_IN: 5693 len = sizeof(struct ice_vlan_hdr); 5694 break; 5695 case ICE_IPV4_OFOS: 5696 case ICE_IPV4_IL: 5697 len = sizeof(struct ice_ipv4_hdr); 5698 break; 5699 case ICE_IPV6_OFOS: 5700 case ICE_IPV6_IL: 5701 len = sizeof(struct ice_ipv6_hdr); 5702 break; 5703 case ICE_TCP_IL: 5704 case ICE_UDP_OF: 5705 case ICE_UDP_ILOS: 5706 len = sizeof(struct ice_l4_hdr); 5707 break; 5708 case ICE_SCTP_IL: 5709 len = sizeof(struct ice_sctp_hdr); 5710 break; 5711 case ICE_NVGRE: 5712 len = sizeof(struct ice_nvgre_hdr); 5713 break; 5714 case ICE_VXLAN: 5715 case ICE_GENEVE: 5716 len = sizeof(struct ice_udp_tnl_hdr); 5717 break; 5718 case ICE_GTP_NO_PAY: 5719 case ICE_GTP: 5720 len = sizeof(struct ice_udp_gtp_hdr); 5721 break; 5722 case ICE_PFCP: 5723 len = sizeof(struct ice_pfcp_hdr); 5724 break; 5725 case ICE_PPPOE: 5726 len = sizeof(struct ice_pppoe_hdr); 5727 break; 5728 case ICE_L2TPV3: 5729 len = sizeof(struct ice_l2tpv3_sess_hdr); 5730 break; 5731 default: 5732 return -EINVAL; 5733 } 5734 5735 /* the length should be a word multiple */ 5736 if (len % ICE_BYTES_PER_WORD) 5737 return -EIO; 5738 5739 /* We have the offset to the header start, the length, the 5740 * caller's header values and mask. Use this information to 5741 * copy the data into the dummy packet appropriately based on 5742 * the mask. Note that we need to only write the bits as 5743 * indicated by the mask to make sure we don't improperly write 5744 * over any significant packet data. 5745 */ 5746 for (j = 0; j < len / sizeof(u16); j++) { 5747 u16 *ptr = (u16 *)(pkt + offset); 5748 u16 mask = lkups[i].m_raw[j]; 5749 5750 if (!mask) 5751 continue; 5752 5753 ptr[j] = (ptr[j] & ~mask) | (lkups[i].h_raw[j] & mask); 5754 } 5755 } 5756 5757 s_rule->hdr_len = cpu_to_le16(profile->pkt_len); 5758 5759 return 0; 5760 } 5761 5762 /** 5763 * ice_fill_adv_packet_tun - fill dummy packet with udp tunnel port 5764 * @hw: pointer to the hardware structure 5765 * @tun_type: tunnel type 5766 * @pkt: dummy packet to fill in 5767 * @offsets: offset info for the dummy packet 5768 */ 5769 static int 5770 ice_fill_adv_packet_tun(struct ice_hw *hw, enum ice_sw_tunnel_type tun_type, 5771 u8 *pkt, const struct ice_dummy_pkt_offsets *offsets) 5772 { 5773 u16 open_port, i; 5774 5775 switch (tun_type) { 5776 case ICE_SW_TUN_VXLAN: 5777 if (!ice_get_open_tunnel_port(hw, &open_port, TNL_VXLAN)) 5778 return -EIO; 5779 break; 5780 case ICE_SW_TUN_GENEVE: 5781 if (!ice_get_open_tunnel_port(hw, &open_port, TNL_GENEVE)) 5782 return -EIO; 5783 break; 5784 default: 5785 /* Nothing needs to be done for this tunnel type */ 5786 return 0; 5787 } 5788 5789 /* Find the outer UDP protocol header and insert the port number */ 5790 for (i = 0; offsets[i].type != ICE_PROTOCOL_LAST; i++) { 5791 if (offsets[i].type == ICE_UDP_OF) { 5792 struct ice_l4_hdr *hdr; 5793 u16 offset; 5794 5795 offset = offsets[i].offset; 5796 hdr = (struct ice_l4_hdr *)&pkt[offset]; 5797 hdr->dst_port = cpu_to_be16(open_port); 5798 5799 return 0; 5800 } 5801 } 5802 5803 return -EIO; 5804 } 5805 5806 /** 5807 * ice_fill_adv_packet_vlan - fill dummy packet with VLAN tag type 5808 * @hw: pointer to hw structure 5809 * @vlan_type: VLAN tag type 5810 * @pkt: dummy packet to fill in 5811 * @offsets: offset info for the dummy packet 5812 */ 5813 static int 5814 ice_fill_adv_packet_vlan(struct ice_hw *hw, u16 vlan_type, u8 *pkt, 5815 const struct ice_dummy_pkt_offsets *offsets) 5816 { 5817 u16 i; 5818 5819 /* Check if there is something to do */ 5820 if (!vlan_type || !ice_is_dvm_ena(hw)) 5821 return 0; 5822 5823 /* Find VLAN header and insert VLAN TPID */ 5824 for (i = 0; offsets[i].type != ICE_PROTOCOL_LAST; i++) { 5825 if (offsets[i].type == ICE_VLAN_OFOS || 5826 offsets[i].type == ICE_VLAN_EX) { 5827 struct ice_vlan_hdr *hdr; 5828 u16 offset; 5829 5830 offset = offsets[i].offset; 5831 hdr = (struct ice_vlan_hdr *)&pkt[offset]; 5832 hdr->type = cpu_to_be16(vlan_type); 5833 5834 return 0; 5835 } 5836 } 5837 5838 return -EIO; 5839 } 5840 5841 static bool ice_rules_equal(const struct ice_adv_rule_info *first, 5842 const struct ice_adv_rule_info *second) 5843 { 5844 return first->sw_act.flag == second->sw_act.flag && 5845 first->tun_type == second->tun_type && 5846 first->vlan_type == second->vlan_type && 5847 first->src_vsi == second->src_vsi && 5848 first->need_pass_l2 == second->need_pass_l2 && 5849 first->allow_pass_l2 == second->allow_pass_l2; 5850 } 5851 5852 /** 5853 * ice_find_adv_rule_entry - Search a rule entry 5854 * @hw: pointer to the hardware structure 5855 * @lkups: lookup elements or match criteria for the advanced recipe, one 5856 * structure per protocol header 5857 * @lkups_cnt: number of protocols 5858 * @recp_id: recipe ID for which we are finding the rule 5859 * @rinfo: other information regarding the rule e.g. priority and action info 5860 * 5861 * Helper function to search for a given advance rule entry 5862 * Returns pointer to entry storing the rule if found 5863 */ 5864 static struct ice_adv_fltr_mgmt_list_entry * 5865 ice_find_adv_rule_entry(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, 5866 u16 lkups_cnt, u16 recp_id, 5867 struct ice_adv_rule_info *rinfo) 5868 { 5869 struct ice_adv_fltr_mgmt_list_entry *list_itr; 5870 struct ice_switch_info *sw = hw->switch_info; 5871 int i; 5872 5873 list_for_each_entry(list_itr, &sw->recp_list[recp_id].filt_rules, 5874 list_entry) { 5875 bool lkups_matched = true; 5876 5877 if (lkups_cnt != list_itr->lkups_cnt) 5878 continue; 5879 for (i = 0; i < list_itr->lkups_cnt; i++) 5880 if (memcmp(&list_itr->lkups[i], &lkups[i], 5881 sizeof(*lkups))) { 5882 lkups_matched = false; 5883 break; 5884 } 5885 if (ice_rules_equal(rinfo, &list_itr->rule_info) && 5886 lkups_matched) 5887 return list_itr; 5888 } 5889 return NULL; 5890 } 5891 5892 /** 5893 * ice_adv_add_update_vsi_list 5894 * @hw: pointer to the hardware structure 5895 * @m_entry: pointer to current adv filter management list entry 5896 * @cur_fltr: filter information from the book keeping entry 5897 * @new_fltr: filter information with the new VSI to be added 5898 * 5899 * Call AQ command to add or update previously created VSI list with new VSI. 5900 * 5901 * Helper function to do book keeping associated with adding filter information 5902 * The algorithm to do the booking keeping is described below : 5903 * When a VSI needs to subscribe to a given advanced filter 5904 * if only one VSI has been added till now 5905 * Allocate a new VSI list and add two VSIs 5906 * to this list using switch rule command 5907 * Update the previously created switch rule with the 5908 * newly created VSI list ID 5909 * if a VSI list was previously created 5910 * Add the new VSI to the previously created VSI list set 5911 * using the update switch rule command 5912 */ 5913 static int 5914 ice_adv_add_update_vsi_list(struct ice_hw *hw, 5915 struct ice_adv_fltr_mgmt_list_entry *m_entry, 5916 struct ice_adv_rule_info *cur_fltr, 5917 struct ice_adv_rule_info *new_fltr) 5918 { 5919 u16 vsi_list_id = 0; 5920 int status; 5921 5922 if (cur_fltr->sw_act.fltr_act == ICE_FWD_TO_Q || 5923 cur_fltr->sw_act.fltr_act == ICE_FWD_TO_QGRP || 5924 cur_fltr->sw_act.fltr_act == ICE_DROP_PACKET) 5925 return -EOPNOTSUPP; 5926 5927 if ((new_fltr->sw_act.fltr_act == ICE_FWD_TO_Q || 5928 new_fltr->sw_act.fltr_act == ICE_FWD_TO_QGRP) && 5929 (cur_fltr->sw_act.fltr_act == ICE_FWD_TO_VSI || 5930 cur_fltr->sw_act.fltr_act == ICE_FWD_TO_VSI_LIST)) 5931 return -EOPNOTSUPP; 5932 5933 if (m_entry->vsi_count < 2 && !m_entry->vsi_list_info) { 5934 /* Only one entry existed in the mapping and it was not already 5935 * a part of a VSI list. So, create a VSI list with the old and 5936 * new VSIs. 5937 */ 5938 struct ice_fltr_info tmp_fltr; 5939 u16 vsi_handle_arr[2]; 5940 5941 /* A rule already exists with the new VSI being added */ 5942 if (cur_fltr->sw_act.fwd_id.hw_vsi_id == 5943 new_fltr->sw_act.fwd_id.hw_vsi_id) 5944 return -EEXIST; 5945 5946 vsi_handle_arr[0] = cur_fltr->sw_act.vsi_handle; 5947 vsi_handle_arr[1] = new_fltr->sw_act.vsi_handle; 5948 status = ice_create_vsi_list_rule(hw, &vsi_handle_arr[0], 2, 5949 &vsi_list_id, 5950 ICE_SW_LKUP_LAST); 5951 if (status) 5952 return status; 5953 5954 memset(&tmp_fltr, 0, sizeof(tmp_fltr)); 5955 tmp_fltr.flag = m_entry->rule_info.sw_act.flag; 5956 tmp_fltr.fltr_rule_id = cur_fltr->fltr_rule_id; 5957 tmp_fltr.fltr_act = ICE_FWD_TO_VSI_LIST; 5958 tmp_fltr.fwd_id.vsi_list_id = vsi_list_id; 5959 tmp_fltr.lkup_type = ICE_SW_LKUP_LAST; 5960 5961 /* Update the previous switch rule of "forward to VSI" to 5962 * "fwd to VSI list" 5963 */ 5964 status = ice_update_pkt_fwd_rule(hw, &tmp_fltr); 5965 if (status) 5966 return status; 5967 5968 cur_fltr->sw_act.fwd_id.vsi_list_id = vsi_list_id; 5969 cur_fltr->sw_act.fltr_act = ICE_FWD_TO_VSI_LIST; 5970 m_entry->vsi_list_info = 5971 ice_create_vsi_list_map(hw, &vsi_handle_arr[0], 2, 5972 vsi_list_id); 5973 } else { 5974 u16 vsi_handle = new_fltr->sw_act.vsi_handle; 5975 5976 if (!m_entry->vsi_list_info) 5977 return -EIO; 5978 5979 /* A rule already exists with the new VSI being added */ 5980 if (test_bit(vsi_handle, m_entry->vsi_list_info->vsi_map)) 5981 return 0; 5982 5983 /* Update the previously created VSI list set with 5984 * the new VSI ID passed in 5985 */ 5986 vsi_list_id = cur_fltr->sw_act.fwd_id.vsi_list_id; 5987 5988 status = ice_update_vsi_list_rule(hw, &vsi_handle, 1, 5989 vsi_list_id, false, 5990 ice_aqc_opc_update_sw_rules, 5991 ICE_SW_LKUP_LAST); 5992 /* update VSI list mapping info with new VSI ID */ 5993 if (!status) 5994 set_bit(vsi_handle, m_entry->vsi_list_info->vsi_map); 5995 } 5996 if (!status) 5997 m_entry->vsi_count++; 5998 return status; 5999 } 6000 6001 void ice_rule_add_tunnel_metadata(struct ice_adv_lkup_elem *lkup) 6002 { 6003 lkup->type = ICE_HW_METADATA; 6004 lkup->m_u.metadata.flags[ICE_PKT_FLAGS_MDID21] |= 6005 cpu_to_be16(ICE_PKT_TUNNEL_MASK); 6006 } 6007 6008 void ice_rule_add_direction_metadata(struct ice_adv_lkup_elem *lkup) 6009 { 6010 lkup->type = ICE_HW_METADATA; 6011 lkup->m_u.metadata.flags[ICE_PKT_FLAGS_MDID20] |= 6012 cpu_to_be16(ICE_PKT_FROM_NETWORK); 6013 } 6014 6015 void ice_rule_add_vlan_metadata(struct ice_adv_lkup_elem *lkup) 6016 { 6017 lkup->type = ICE_HW_METADATA; 6018 lkup->m_u.metadata.flags[ICE_PKT_FLAGS_MDID20] |= 6019 cpu_to_be16(ICE_PKT_VLAN_MASK); 6020 } 6021 6022 void ice_rule_add_src_vsi_metadata(struct ice_adv_lkup_elem *lkup) 6023 { 6024 lkup->type = ICE_HW_METADATA; 6025 lkup->m_u.metadata.source_vsi = cpu_to_be16(ICE_MDID_SOURCE_VSI_MASK); 6026 } 6027 6028 /** 6029 * ice_add_adv_rule - helper function to create an advanced switch rule 6030 * @hw: pointer to the hardware structure 6031 * @lkups: information on the words that needs to be looked up. All words 6032 * together makes one recipe 6033 * @lkups_cnt: num of entries in the lkups array 6034 * @rinfo: other information related to the rule that needs to be programmed 6035 * @added_entry: this will return recipe_id, rule_id and vsi_handle. should be 6036 * ignored is case of error. 6037 * 6038 * This function can program only 1 rule at a time. The lkups is used to 6039 * describe the all the words that forms the "lookup" portion of the recipe. 6040 * These words can span multiple protocols. Callers to this function need to 6041 * pass in a list of protocol headers with lookup information along and mask 6042 * that determines which words are valid from the given protocol header. 6043 * rinfo describes other information related to this rule such as forwarding 6044 * IDs, priority of this rule, etc. 6045 */ 6046 int 6047 ice_add_adv_rule(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, 6048 u16 lkups_cnt, struct ice_adv_rule_info *rinfo, 6049 struct ice_rule_query_data *added_entry) 6050 { 6051 struct ice_adv_fltr_mgmt_list_entry *m_entry, *adv_fltr = NULL; 6052 struct ice_sw_rule_lkup_rx_tx *s_rule = NULL; 6053 const struct ice_dummy_pkt_profile *profile; 6054 u16 rid = 0, i, rule_buf_sz, vsi_handle; 6055 struct list_head *rule_head; 6056 struct ice_switch_info *sw; 6057 u16 word_cnt; 6058 u32 act = 0; 6059 int status; 6060 u8 q_rgn; 6061 6062 /* Initialize profile to result index bitmap */ 6063 if (!hw->switch_info->prof_res_bm_init) { 6064 hw->switch_info->prof_res_bm_init = 1; 6065 ice_init_prof_result_bm(hw); 6066 } 6067 6068 if (!lkups_cnt) 6069 return -EINVAL; 6070 6071 /* get # of words we need to match */ 6072 word_cnt = 0; 6073 for (i = 0; i < lkups_cnt; i++) { 6074 u16 j; 6075 6076 for (j = 0; j < ARRAY_SIZE(lkups->m_raw); j++) 6077 if (lkups[i].m_raw[j]) 6078 word_cnt++; 6079 } 6080 6081 if (!word_cnt) 6082 return -EINVAL; 6083 6084 if (word_cnt > ICE_MAX_CHAIN_WORDS) 6085 return -ENOSPC; 6086 6087 /* locate a dummy packet */ 6088 profile = ice_find_dummy_packet(lkups, lkups_cnt, rinfo->tun_type); 6089 if (IS_ERR(profile)) 6090 return PTR_ERR(profile); 6091 6092 if (!(rinfo->sw_act.fltr_act == ICE_FWD_TO_VSI || 6093 rinfo->sw_act.fltr_act == ICE_FWD_TO_Q || 6094 rinfo->sw_act.fltr_act == ICE_FWD_TO_QGRP || 6095 rinfo->sw_act.fltr_act == ICE_DROP_PACKET || 6096 rinfo->sw_act.fltr_act == ICE_MIRROR_PACKET || 6097 rinfo->sw_act.fltr_act == ICE_NOP)) { 6098 status = -EIO; 6099 goto free_pkt_profile; 6100 } 6101 6102 vsi_handle = rinfo->sw_act.vsi_handle; 6103 if (!ice_is_vsi_valid(hw, vsi_handle)) { 6104 status = -EINVAL; 6105 goto free_pkt_profile; 6106 } 6107 6108 if (rinfo->sw_act.fltr_act == ICE_FWD_TO_VSI || 6109 rinfo->sw_act.fltr_act == ICE_MIRROR_PACKET || 6110 rinfo->sw_act.fltr_act == ICE_NOP) { 6111 rinfo->sw_act.fwd_id.hw_vsi_id = 6112 ice_get_hw_vsi_num(hw, vsi_handle); 6113 } 6114 6115 if (rinfo->src_vsi) 6116 rinfo->sw_act.src = ice_get_hw_vsi_num(hw, rinfo->src_vsi); 6117 else 6118 rinfo->sw_act.src = ice_get_hw_vsi_num(hw, vsi_handle); 6119 6120 status = ice_add_adv_recipe(hw, lkups, lkups_cnt, rinfo, &rid); 6121 if (status) 6122 goto free_pkt_profile; 6123 m_entry = ice_find_adv_rule_entry(hw, lkups, lkups_cnt, rid, rinfo); 6124 if (m_entry) { 6125 /* we have to add VSI to VSI_LIST and increment vsi_count. 6126 * Also Update VSI list so that we can change forwarding rule 6127 * if the rule already exists, we will check if it exists with 6128 * same vsi_id, if not then add it to the VSI list if it already 6129 * exists if not then create a VSI list and add the existing VSI 6130 * ID and the new VSI ID to the list 6131 * We will add that VSI to the list 6132 */ 6133 status = ice_adv_add_update_vsi_list(hw, m_entry, 6134 &m_entry->rule_info, 6135 rinfo); 6136 if (added_entry) { 6137 added_entry->rid = rid; 6138 added_entry->rule_id = m_entry->rule_info.fltr_rule_id; 6139 added_entry->vsi_handle = rinfo->sw_act.vsi_handle; 6140 } 6141 goto free_pkt_profile; 6142 } 6143 rule_buf_sz = ICE_SW_RULE_RX_TX_HDR_SIZE(s_rule, profile->pkt_len); 6144 s_rule = kzalloc(rule_buf_sz, GFP_KERNEL); 6145 if (!s_rule) { 6146 status = -ENOMEM; 6147 goto free_pkt_profile; 6148 } 6149 6150 if (rinfo->sw_act.fltr_act != ICE_MIRROR_PACKET) { 6151 if (!rinfo->flags_info.act_valid) { 6152 act |= ICE_SINGLE_ACT_LAN_ENABLE; 6153 act |= ICE_SINGLE_ACT_LB_ENABLE; 6154 } else { 6155 act |= rinfo->flags_info.act & (ICE_SINGLE_ACT_LAN_ENABLE | 6156 ICE_SINGLE_ACT_LB_ENABLE); 6157 } 6158 } 6159 6160 switch (rinfo->sw_act.fltr_act) { 6161 case ICE_FWD_TO_VSI: 6162 act |= FIELD_PREP(ICE_SINGLE_ACT_VSI_ID_M, 6163 rinfo->sw_act.fwd_id.hw_vsi_id); 6164 act |= ICE_SINGLE_ACT_VSI_FORWARDING | ICE_SINGLE_ACT_VALID_BIT; 6165 break; 6166 case ICE_FWD_TO_Q: 6167 act |= ICE_SINGLE_ACT_TO_Q; 6168 act |= FIELD_PREP(ICE_SINGLE_ACT_Q_INDEX_M, 6169 rinfo->sw_act.fwd_id.q_id); 6170 break; 6171 case ICE_FWD_TO_QGRP: 6172 q_rgn = rinfo->sw_act.qgrp_size > 0 ? 6173 (u8)ilog2(rinfo->sw_act.qgrp_size) : 0; 6174 act |= ICE_SINGLE_ACT_TO_Q; 6175 act |= FIELD_PREP(ICE_SINGLE_ACT_Q_INDEX_M, 6176 rinfo->sw_act.fwd_id.q_id); 6177 act |= FIELD_PREP(ICE_SINGLE_ACT_Q_REGION_M, q_rgn); 6178 break; 6179 case ICE_DROP_PACKET: 6180 act |= ICE_SINGLE_ACT_VSI_FORWARDING | ICE_SINGLE_ACT_DROP | 6181 ICE_SINGLE_ACT_VALID_BIT; 6182 break; 6183 case ICE_MIRROR_PACKET: 6184 act |= ICE_SINGLE_ACT_OTHER_ACTS; 6185 act |= FIELD_PREP(ICE_SINGLE_ACT_VSI_ID_M, 6186 rinfo->sw_act.fwd_id.hw_vsi_id); 6187 break; 6188 case ICE_NOP: 6189 act |= FIELD_PREP(ICE_SINGLE_ACT_VSI_ID_M, 6190 rinfo->sw_act.fwd_id.hw_vsi_id); 6191 act &= ~ICE_SINGLE_ACT_VALID_BIT; 6192 break; 6193 default: 6194 status = -EIO; 6195 goto err_ice_add_adv_rule; 6196 } 6197 6198 /* If there is no matching criteria for direction there 6199 * is only one difference between Rx and Tx: 6200 * - get switch id base on VSI number from source field (Tx) 6201 * - get switch id base on port number (Rx) 6202 * 6203 * If matching on direction metadata is chose rule direction is 6204 * extracted from type value set here. 6205 */ 6206 if (rinfo->sw_act.flag & ICE_FLTR_TX) { 6207 s_rule->hdr.type = cpu_to_le16(ICE_AQC_SW_RULES_T_LKUP_TX); 6208 s_rule->src = cpu_to_le16(rinfo->sw_act.src); 6209 } else { 6210 s_rule->hdr.type = cpu_to_le16(ICE_AQC_SW_RULES_T_LKUP_RX); 6211 s_rule->src = cpu_to_le16(hw->port_info->lport); 6212 } 6213 6214 s_rule->recipe_id = cpu_to_le16(rid); 6215 s_rule->act = cpu_to_le32(act); 6216 6217 status = ice_fill_adv_dummy_packet(lkups, lkups_cnt, s_rule, profile); 6218 if (status) 6219 goto err_ice_add_adv_rule; 6220 6221 status = ice_fill_adv_packet_tun(hw, rinfo->tun_type, s_rule->hdr_data, 6222 profile->offsets); 6223 if (status) 6224 goto err_ice_add_adv_rule; 6225 6226 status = ice_fill_adv_packet_vlan(hw, rinfo->vlan_type, 6227 s_rule->hdr_data, 6228 profile->offsets); 6229 if (status) 6230 goto err_ice_add_adv_rule; 6231 6232 status = ice_aq_sw_rules(hw, (struct ice_aqc_sw_rules *)s_rule, 6233 rule_buf_sz, 1, ice_aqc_opc_add_sw_rules, 6234 NULL); 6235 if (status) 6236 goto err_ice_add_adv_rule; 6237 adv_fltr = devm_kzalloc(ice_hw_to_dev(hw), 6238 sizeof(struct ice_adv_fltr_mgmt_list_entry), 6239 GFP_KERNEL); 6240 if (!adv_fltr) { 6241 status = -ENOMEM; 6242 goto err_ice_add_adv_rule; 6243 } 6244 6245 adv_fltr->lkups = devm_kmemdup(ice_hw_to_dev(hw), lkups, 6246 lkups_cnt * sizeof(*lkups), GFP_KERNEL); 6247 if (!adv_fltr->lkups) { 6248 status = -ENOMEM; 6249 goto err_ice_add_adv_rule; 6250 } 6251 6252 adv_fltr->lkups_cnt = lkups_cnt; 6253 adv_fltr->rule_info = *rinfo; 6254 adv_fltr->rule_info.fltr_rule_id = le16_to_cpu(s_rule->index); 6255 sw = hw->switch_info; 6256 sw->recp_list[rid].adv_rule = true; 6257 rule_head = &sw->recp_list[rid].filt_rules; 6258 6259 if (rinfo->sw_act.fltr_act == ICE_FWD_TO_VSI) 6260 adv_fltr->vsi_count = 1; 6261 6262 /* Add rule entry to book keeping list */ 6263 list_add(&adv_fltr->list_entry, rule_head); 6264 if (added_entry) { 6265 added_entry->rid = rid; 6266 added_entry->rule_id = adv_fltr->rule_info.fltr_rule_id; 6267 added_entry->vsi_handle = rinfo->sw_act.vsi_handle; 6268 } 6269 err_ice_add_adv_rule: 6270 if (status && adv_fltr) { 6271 devm_kfree(ice_hw_to_dev(hw), adv_fltr->lkups); 6272 devm_kfree(ice_hw_to_dev(hw), adv_fltr); 6273 } 6274 6275 kfree(s_rule); 6276 6277 free_pkt_profile: 6278 if (profile->match & ICE_PKT_KMALLOC) { 6279 kfree(profile->offsets); 6280 kfree(profile->pkt); 6281 kfree(profile); 6282 } 6283 6284 return status; 6285 } 6286 6287 /** 6288 * ice_replay_vsi_fltr - Replay filters for requested VSI 6289 * @hw: pointer to the hardware structure 6290 * @vsi_handle: driver VSI handle 6291 * @recp_id: Recipe ID for which rules need to be replayed 6292 * @list_head: list for which filters need to be replayed 6293 * 6294 * Replays the filter of recipe recp_id for a VSI represented via vsi_handle. 6295 * It is required to pass valid VSI handle. 6296 */ 6297 static int 6298 ice_replay_vsi_fltr(struct ice_hw *hw, u16 vsi_handle, u8 recp_id, 6299 struct list_head *list_head) 6300 { 6301 struct ice_fltr_mgmt_list_entry *itr; 6302 int status = 0; 6303 u16 hw_vsi_id; 6304 6305 if (list_empty(list_head)) 6306 return status; 6307 hw_vsi_id = ice_get_hw_vsi_num(hw, vsi_handle); 6308 6309 list_for_each_entry(itr, list_head, list_entry) { 6310 struct ice_fltr_list_entry f_entry; 6311 6312 f_entry.fltr_info = itr->fltr_info; 6313 if (itr->vsi_count < 2 && recp_id != ICE_SW_LKUP_VLAN && 6314 itr->fltr_info.vsi_handle == vsi_handle) { 6315 /* update the src in case it is VSI num */ 6316 if (f_entry.fltr_info.src_id == ICE_SRC_ID_VSI) 6317 f_entry.fltr_info.src = hw_vsi_id; 6318 status = ice_add_rule_internal(hw, recp_id, &f_entry); 6319 if (status) 6320 goto end; 6321 continue; 6322 } 6323 if (!itr->vsi_list_info || 6324 !test_bit(vsi_handle, itr->vsi_list_info->vsi_map)) 6325 continue; 6326 f_entry.fltr_info.vsi_handle = vsi_handle; 6327 f_entry.fltr_info.fltr_act = ICE_FWD_TO_VSI; 6328 /* update the src in case it is VSI num */ 6329 if (f_entry.fltr_info.src_id == ICE_SRC_ID_VSI) 6330 f_entry.fltr_info.src = hw_vsi_id; 6331 if (recp_id == ICE_SW_LKUP_VLAN) 6332 status = ice_add_vlan_internal(hw, &f_entry); 6333 else 6334 status = ice_add_rule_internal(hw, recp_id, &f_entry); 6335 if (status) 6336 goto end; 6337 } 6338 end: 6339 return status; 6340 } 6341 6342 /** 6343 * ice_adv_rem_update_vsi_list 6344 * @hw: pointer to the hardware structure 6345 * @vsi_handle: VSI handle of the VSI to remove 6346 * @fm_list: filter management entry for which the VSI list management needs to 6347 * be done 6348 */ 6349 static int 6350 ice_adv_rem_update_vsi_list(struct ice_hw *hw, u16 vsi_handle, 6351 struct ice_adv_fltr_mgmt_list_entry *fm_list) 6352 { 6353 struct ice_vsi_list_map_info *vsi_list_info; 6354 enum ice_sw_lkup_type lkup_type; 6355 u16 vsi_list_id; 6356 int status; 6357 6358 if (fm_list->rule_info.sw_act.fltr_act != ICE_FWD_TO_VSI_LIST || 6359 fm_list->vsi_count == 0) 6360 return -EINVAL; 6361 6362 /* A rule with the VSI being removed does not exist */ 6363 if (!test_bit(vsi_handle, fm_list->vsi_list_info->vsi_map)) 6364 return -ENOENT; 6365 6366 lkup_type = ICE_SW_LKUP_LAST; 6367 vsi_list_id = fm_list->rule_info.sw_act.fwd_id.vsi_list_id; 6368 status = ice_update_vsi_list_rule(hw, &vsi_handle, 1, vsi_list_id, true, 6369 ice_aqc_opc_update_sw_rules, 6370 lkup_type); 6371 if (status) 6372 return status; 6373 6374 fm_list->vsi_count--; 6375 clear_bit(vsi_handle, fm_list->vsi_list_info->vsi_map); 6376 vsi_list_info = fm_list->vsi_list_info; 6377 if (fm_list->vsi_count == 1) { 6378 struct ice_fltr_info tmp_fltr; 6379 u16 rem_vsi_handle; 6380 6381 rem_vsi_handle = find_first_bit(vsi_list_info->vsi_map, 6382 ICE_MAX_VSI); 6383 if (!ice_is_vsi_valid(hw, rem_vsi_handle)) 6384 return -EIO; 6385 6386 /* Make sure VSI list is empty before removing it below */ 6387 status = ice_update_vsi_list_rule(hw, &rem_vsi_handle, 1, 6388 vsi_list_id, true, 6389 ice_aqc_opc_update_sw_rules, 6390 lkup_type); 6391 if (status) 6392 return status; 6393 6394 memset(&tmp_fltr, 0, sizeof(tmp_fltr)); 6395 tmp_fltr.flag = fm_list->rule_info.sw_act.flag; 6396 tmp_fltr.fltr_rule_id = fm_list->rule_info.fltr_rule_id; 6397 fm_list->rule_info.sw_act.fltr_act = ICE_FWD_TO_VSI; 6398 tmp_fltr.fltr_act = ICE_FWD_TO_VSI; 6399 tmp_fltr.fwd_id.hw_vsi_id = 6400 ice_get_hw_vsi_num(hw, rem_vsi_handle); 6401 fm_list->rule_info.sw_act.fwd_id.hw_vsi_id = 6402 ice_get_hw_vsi_num(hw, rem_vsi_handle); 6403 fm_list->rule_info.sw_act.vsi_handle = rem_vsi_handle; 6404 6405 /* Update the previous switch rule of "MAC forward to VSI" to 6406 * "MAC fwd to VSI list" 6407 */ 6408 status = ice_update_pkt_fwd_rule(hw, &tmp_fltr); 6409 if (status) { 6410 ice_debug(hw, ICE_DBG_SW, "Failed to update pkt fwd rule to FWD_TO_VSI on HW VSI %d, error %d\n", 6411 tmp_fltr.fwd_id.hw_vsi_id, status); 6412 return status; 6413 } 6414 fm_list->vsi_list_info->ref_cnt--; 6415 6416 /* Remove the VSI list since it is no longer used */ 6417 status = ice_remove_vsi_list_rule(hw, vsi_list_id, lkup_type); 6418 if (status) { 6419 ice_debug(hw, ICE_DBG_SW, "Failed to remove VSI list %d, error %d\n", 6420 vsi_list_id, status); 6421 return status; 6422 } 6423 6424 list_del(&vsi_list_info->list_entry); 6425 devm_kfree(ice_hw_to_dev(hw), vsi_list_info); 6426 fm_list->vsi_list_info = NULL; 6427 } 6428 6429 return status; 6430 } 6431 6432 /** 6433 * ice_rem_adv_rule - removes existing advanced switch rule 6434 * @hw: pointer to the hardware structure 6435 * @lkups: information on the words that needs to be looked up. All words 6436 * together makes one recipe 6437 * @lkups_cnt: num of entries in the lkups array 6438 * @rinfo: Its the pointer to the rule information for the rule 6439 * 6440 * This function can be used to remove 1 rule at a time. The lkups is 6441 * used to describe all the words that forms the "lookup" portion of the 6442 * rule. These words can span multiple protocols. Callers to this function 6443 * need to pass in a list of protocol headers with lookup information along 6444 * and mask that determines which words are valid from the given protocol 6445 * header. rinfo describes other information related to this rule such as 6446 * forwarding IDs, priority of this rule, etc. 6447 */ 6448 static int 6449 ice_rem_adv_rule(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, 6450 u16 lkups_cnt, struct ice_adv_rule_info *rinfo) 6451 { 6452 struct ice_adv_fltr_mgmt_list_entry *list_elem; 6453 struct ice_prot_lkup_ext lkup_exts; 6454 bool remove_rule = false; 6455 struct mutex *rule_lock; /* Lock to protect filter rule list */ 6456 u16 i, rid, vsi_handle; 6457 int status = 0; 6458 6459 memset(&lkup_exts, 0, sizeof(lkup_exts)); 6460 for (i = 0; i < lkups_cnt; i++) { 6461 u16 count; 6462 6463 if (lkups[i].type >= ICE_PROTOCOL_LAST) 6464 return -EIO; 6465 6466 count = ice_fill_valid_words(&lkups[i], &lkup_exts); 6467 if (!count) 6468 return -EIO; 6469 } 6470 6471 rid = ice_find_recp(hw, &lkup_exts, rinfo, false); 6472 /* If did not find a recipe that match the existing criteria */ 6473 if (rid == ICE_MAX_NUM_RECIPES) 6474 return -EINVAL; 6475 6476 rule_lock = &hw->switch_info->recp_list[rid].filt_rule_lock; 6477 list_elem = ice_find_adv_rule_entry(hw, lkups, lkups_cnt, rid, rinfo); 6478 /* the rule is already removed */ 6479 if (!list_elem) 6480 return 0; 6481 mutex_lock(rule_lock); 6482 if (list_elem->rule_info.sw_act.fltr_act != ICE_FWD_TO_VSI_LIST) { 6483 remove_rule = true; 6484 } else if (list_elem->vsi_count > 1) { 6485 remove_rule = false; 6486 vsi_handle = rinfo->sw_act.vsi_handle; 6487 status = ice_adv_rem_update_vsi_list(hw, vsi_handle, list_elem); 6488 } else { 6489 vsi_handle = rinfo->sw_act.vsi_handle; 6490 status = ice_adv_rem_update_vsi_list(hw, vsi_handle, list_elem); 6491 if (status) { 6492 mutex_unlock(rule_lock); 6493 return status; 6494 } 6495 if (list_elem->vsi_count == 0) 6496 remove_rule = true; 6497 } 6498 mutex_unlock(rule_lock); 6499 if (remove_rule) { 6500 struct ice_sw_rule_lkup_rx_tx *s_rule; 6501 u16 rule_buf_sz; 6502 6503 rule_buf_sz = ICE_SW_RULE_RX_TX_NO_HDR_SIZE(s_rule); 6504 s_rule = kzalloc(rule_buf_sz, GFP_KERNEL); 6505 if (!s_rule) 6506 return -ENOMEM; 6507 s_rule->act = 0; 6508 s_rule->index = cpu_to_le16(list_elem->rule_info.fltr_rule_id); 6509 s_rule->hdr_len = 0; 6510 status = ice_aq_sw_rules(hw, (struct ice_aqc_sw_rules *)s_rule, 6511 rule_buf_sz, 1, 6512 ice_aqc_opc_remove_sw_rules, NULL); 6513 if (!status || status == -ENOENT) { 6514 struct ice_switch_info *sw = hw->switch_info; 6515 struct ice_sw_recipe *r_list = sw->recp_list; 6516 6517 mutex_lock(rule_lock); 6518 list_del(&list_elem->list_entry); 6519 devm_kfree(ice_hw_to_dev(hw), list_elem->lkups); 6520 devm_kfree(ice_hw_to_dev(hw), list_elem); 6521 mutex_unlock(rule_lock); 6522 if (list_empty(&r_list[rid].filt_rules)) { 6523 r_list[rid].adv_rule = false; 6524 6525 /* All rules for this recipe are now removed */ 6526 if (hw->recp_reuse) 6527 ice_release_recipe_res(hw, 6528 &r_list[rid]); 6529 } 6530 } 6531 kfree(s_rule); 6532 } 6533 return status; 6534 } 6535 6536 /** 6537 * ice_rem_adv_rule_by_id - removes existing advanced switch rule by ID 6538 * @hw: pointer to the hardware structure 6539 * @remove_entry: data struct which holds rule_id, VSI handle and recipe ID 6540 * 6541 * This function is used to remove 1 rule at a time. The removal is based on 6542 * the remove_entry parameter. This function will remove rule for a given 6543 * vsi_handle with a given rule_id which is passed as parameter in remove_entry 6544 */ 6545 int 6546 ice_rem_adv_rule_by_id(struct ice_hw *hw, 6547 struct ice_rule_query_data *remove_entry) 6548 { 6549 struct ice_adv_fltr_mgmt_list_entry *list_itr; 6550 struct list_head *list_head; 6551 struct ice_adv_rule_info rinfo; 6552 struct ice_switch_info *sw; 6553 6554 sw = hw->switch_info; 6555 if (!sw->recp_list[remove_entry->rid].recp_created) 6556 return -EINVAL; 6557 list_head = &sw->recp_list[remove_entry->rid].filt_rules; 6558 list_for_each_entry(list_itr, list_head, list_entry) { 6559 if (list_itr->rule_info.fltr_rule_id == 6560 remove_entry->rule_id) { 6561 rinfo = list_itr->rule_info; 6562 rinfo.sw_act.vsi_handle = remove_entry->vsi_handle; 6563 return ice_rem_adv_rule(hw, list_itr->lkups, 6564 list_itr->lkups_cnt, &rinfo); 6565 } 6566 } 6567 /* either list is empty or unable to find rule */ 6568 return -ENOENT; 6569 } 6570 6571 /** 6572 * ice_replay_vsi_adv_rule - Replay advanced rule for requested VSI 6573 * @hw: pointer to the hardware structure 6574 * @vsi_handle: driver VSI handle 6575 * @list_head: list for which filters need to be replayed 6576 * 6577 * Replay the advanced rule for the given VSI. 6578 */ 6579 static int 6580 ice_replay_vsi_adv_rule(struct ice_hw *hw, u16 vsi_handle, 6581 struct list_head *list_head) 6582 { 6583 struct ice_rule_query_data added_entry = { 0 }; 6584 struct ice_adv_fltr_mgmt_list_entry *adv_fltr; 6585 int status = 0; 6586 6587 if (list_empty(list_head)) 6588 return status; 6589 list_for_each_entry(adv_fltr, list_head, list_entry) { 6590 struct ice_adv_rule_info *rinfo = &adv_fltr->rule_info; 6591 u16 lk_cnt = adv_fltr->lkups_cnt; 6592 6593 if (vsi_handle != rinfo->sw_act.vsi_handle) 6594 continue; 6595 status = ice_add_adv_rule(hw, adv_fltr->lkups, lk_cnt, rinfo, 6596 &added_entry); 6597 if (status) 6598 break; 6599 } 6600 return status; 6601 } 6602 6603 /** 6604 * ice_replay_vsi_all_fltr - replay all filters stored in bookkeeping lists 6605 * @hw: pointer to the hardware structure 6606 * @vsi_handle: driver VSI handle 6607 * 6608 * Replays filters for requested VSI via vsi_handle. 6609 */ 6610 int ice_replay_vsi_all_fltr(struct ice_hw *hw, u16 vsi_handle) 6611 { 6612 struct ice_switch_info *sw = hw->switch_info; 6613 int status; 6614 u8 i; 6615 6616 for (i = 0; i < ICE_MAX_NUM_RECIPES; i++) { 6617 struct list_head *head; 6618 6619 head = &sw->recp_list[i].filt_replay_rules; 6620 if (!sw->recp_list[i].adv_rule) 6621 status = ice_replay_vsi_fltr(hw, vsi_handle, i, head); 6622 else 6623 status = ice_replay_vsi_adv_rule(hw, vsi_handle, head); 6624 if (status) 6625 return status; 6626 } 6627 return status; 6628 } 6629 6630 /** 6631 * ice_rm_all_sw_replay_rule_info - deletes filter replay rules 6632 * @hw: pointer to the HW struct 6633 * 6634 * Deletes the filter replay rules. 6635 */ 6636 void ice_rm_all_sw_replay_rule_info(struct ice_hw *hw) 6637 { 6638 struct ice_switch_info *sw = hw->switch_info; 6639 u8 i; 6640 6641 if (!sw) 6642 return; 6643 6644 for (i = 0; i < ICE_MAX_NUM_RECIPES; i++) { 6645 if (!list_empty(&sw->recp_list[i].filt_replay_rules)) { 6646 struct list_head *l_head; 6647 6648 l_head = &sw->recp_list[i].filt_replay_rules; 6649 if (!sw->recp_list[i].adv_rule) 6650 ice_rem_sw_rule_info(hw, l_head); 6651 else 6652 ice_rem_adv_rule_info(hw, l_head); 6653 } 6654 } 6655 } 6656