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