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