xref: /linux/drivers/net/ethernet/intel/ice/ice_tc_lib.c (revision c5288cda69ee2d8607f5026bd599a5cebf0ee783)
1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2019-2021, Intel Corporation. */
3 
4 #include "ice.h"
5 #include "ice_tc_lib.h"
6 #include "ice_fltr.h"
7 #include "ice_lib.h"
8 #include "ice_protocol_type.h"
9 
10 #define ICE_TC_METADATA_LKUP_IDX 0
11 
12 /**
13  * ice_tc_count_lkups - determine lookup count for switch filter
14  * @flags: TC-flower flags
15  * @headers: Pointer to TC flower filter header structure
16  * @fltr: Pointer to outer TC filter structure
17  *
18  * Determine lookup count based on TC flower input for switch filter.
19  */
20 static int
21 ice_tc_count_lkups(u32 flags, struct ice_tc_flower_lyr_2_4_hdrs *headers,
22 		   struct ice_tc_flower_fltr *fltr)
23 {
24 	int lkups_cnt = 1; /* 0th lookup is metadata */
25 
26 	/* Always add metadata as the 0th lookup. Included elements:
27 	 * - Direction flag (always present)
28 	 * - ICE_TC_FLWR_FIELD_VLAN_TPID (present if specified)
29 	 * - Tunnel flag (present if tunnel)
30 	 */
31 	if (fltr->direction == ICE_ESWITCH_FLTR_EGRESS)
32 		lkups_cnt++;
33 
34 	if (flags & ICE_TC_FLWR_FIELD_TENANT_ID)
35 		lkups_cnt++;
36 
37 	if (flags & ICE_TC_FLWR_FIELD_ENC_DST_MAC)
38 		lkups_cnt++;
39 
40 	if (flags & ICE_TC_FLWR_FIELD_GTP_OPTS)
41 		lkups_cnt++;
42 
43 	if (flags & ICE_TC_FLWR_FIELD_PFCP_OPTS)
44 		lkups_cnt++;
45 
46 	if (flags & (ICE_TC_FLWR_FIELD_ENC_SRC_IPV4 |
47 		     ICE_TC_FLWR_FIELD_ENC_DEST_IPV4 |
48 		     ICE_TC_FLWR_FIELD_ENC_SRC_IPV6 |
49 		     ICE_TC_FLWR_FIELD_ENC_DEST_IPV6))
50 		lkups_cnt++;
51 
52 	if (flags & (ICE_TC_FLWR_FIELD_ENC_IP_TOS |
53 		     ICE_TC_FLWR_FIELD_ENC_IP_TTL))
54 		lkups_cnt++;
55 
56 	if (flags & ICE_TC_FLWR_FIELD_ENC_DEST_L4_PORT)
57 		lkups_cnt++;
58 
59 	if (flags & ICE_TC_FLWR_FIELD_ETH_TYPE_ID)
60 		lkups_cnt++;
61 
62 	/* are MAC fields specified? */
63 	if (flags & (ICE_TC_FLWR_FIELD_DST_MAC | ICE_TC_FLWR_FIELD_SRC_MAC))
64 		lkups_cnt++;
65 
66 	/* is VLAN specified? */
67 	if (flags & (ICE_TC_FLWR_FIELD_VLAN | ICE_TC_FLWR_FIELD_VLAN_PRIO))
68 		lkups_cnt++;
69 
70 	/* is CVLAN specified? */
71 	if (flags & (ICE_TC_FLWR_FIELD_CVLAN | ICE_TC_FLWR_FIELD_CVLAN_PRIO))
72 		lkups_cnt++;
73 
74 	/* are PPPoE options specified? */
75 	if (flags & (ICE_TC_FLWR_FIELD_PPPOE_SESSID |
76 		     ICE_TC_FLWR_FIELD_PPP_PROTO))
77 		lkups_cnt++;
78 
79 	/* are IPv[4|6] fields specified? */
80 	if (flags & (ICE_TC_FLWR_FIELD_DEST_IPV4 | ICE_TC_FLWR_FIELD_SRC_IPV4 |
81 		     ICE_TC_FLWR_FIELD_DEST_IPV6 | ICE_TC_FLWR_FIELD_SRC_IPV6))
82 		lkups_cnt++;
83 
84 	if (flags & (ICE_TC_FLWR_FIELD_IP_TOS | ICE_TC_FLWR_FIELD_IP_TTL))
85 		lkups_cnt++;
86 
87 	/* are L2TPv3 options specified? */
88 	if (flags & ICE_TC_FLWR_FIELD_L2TPV3_SESSID)
89 		lkups_cnt++;
90 
91 	/* is L4 (TCP/UDP/any other L4 protocol fields) specified? */
92 	if (flags & (ICE_TC_FLWR_FIELD_DEST_L4_PORT |
93 		     ICE_TC_FLWR_FIELD_SRC_L4_PORT))
94 		lkups_cnt++;
95 
96 	return lkups_cnt;
97 }
98 
99 static enum ice_protocol_type ice_proto_type_from_mac(bool inner)
100 {
101 	return inner ? ICE_MAC_IL : ICE_MAC_OFOS;
102 }
103 
104 static enum ice_protocol_type ice_proto_type_from_etype(bool inner)
105 {
106 	return inner ? ICE_ETYPE_IL : ICE_ETYPE_OL;
107 }
108 
109 static enum ice_protocol_type ice_proto_type_from_ipv4(bool inner)
110 {
111 	return inner ? ICE_IPV4_IL : ICE_IPV4_OFOS;
112 }
113 
114 static enum ice_protocol_type ice_proto_type_from_ipv6(bool inner)
115 {
116 	return inner ? ICE_IPV6_IL : ICE_IPV6_OFOS;
117 }
118 
119 static enum ice_protocol_type ice_proto_type_from_l4_port(u16 ip_proto)
120 {
121 	switch (ip_proto) {
122 	case IPPROTO_TCP:
123 		return ICE_TCP_IL;
124 	case IPPROTO_UDP:
125 		return ICE_UDP_ILOS;
126 	}
127 
128 	return 0;
129 }
130 
131 static enum ice_protocol_type
132 ice_proto_type_from_tunnel(enum ice_tunnel_type type)
133 {
134 	switch (type) {
135 	case TNL_VXLAN:
136 		return ICE_VXLAN;
137 	case TNL_GENEVE:
138 		return ICE_GENEVE;
139 	case TNL_GRETAP:
140 		return ICE_NVGRE;
141 	case TNL_GTPU:
142 		/* NO_PAY profiles will not work with GTP-U */
143 		return ICE_GTP;
144 	case TNL_GTPC:
145 		return ICE_GTP_NO_PAY;
146 	case TNL_PFCP:
147 		return ICE_PFCP;
148 	default:
149 		return 0;
150 	}
151 }
152 
153 static enum ice_sw_tunnel_type
154 ice_sw_type_from_tunnel(enum ice_tunnel_type type)
155 {
156 	switch (type) {
157 	case TNL_VXLAN:
158 		return ICE_SW_TUN_VXLAN;
159 	case TNL_GENEVE:
160 		return ICE_SW_TUN_GENEVE;
161 	case TNL_GRETAP:
162 		return ICE_SW_TUN_NVGRE;
163 	case TNL_GTPU:
164 		return ICE_SW_TUN_GTPU;
165 	case TNL_GTPC:
166 		return ICE_SW_TUN_GTPC;
167 	case TNL_PFCP:
168 		return ICE_SW_TUN_PFCP;
169 	default:
170 		return ICE_NON_TUN;
171 	}
172 }
173 
174 static u16 ice_check_supported_vlan_tpid(u16 vlan_tpid)
175 {
176 	switch (vlan_tpid) {
177 	case ETH_P_8021Q:
178 	case ETH_P_8021AD:
179 	case ETH_P_QINQ1:
180 		return vlan_tpid;
181 	default:
182 		return 0;
183 	}
184 }
185 
186 static int
187 ice_tc_fill_tunnel_outer(u32 flags, struct ice_tc_flower_fltr *fltr,
188 			 struct ice_adv_lkup_elem *list, int i)
189 {
190 	struct ice_tc_flower_lyr_2_4_hdrs *hdr = &fltr->outer_headers;
191 
192 	if (flags & ICE_TC_FLWR_FIELD_TENANT_ID) {
193 		u32 tenant_id;
194 
195 		list[i].type = ice_proto_type_from_tunnel(fltr->tunnel_type);
196 		switch (fltr->tunnel_type) {
197 		case TNL_VXLAN:
198 		case TNL_GENEVE:
199 			tenant_id = be32_to_cpu(fltr->tenant_id) << 8;
200 			list[i].h_u.tnl_hdr.vni = cpu_to_be32(tenant_id);
201 			memcpy(&list[i].m_u.tnl_hdr.vni, "\xff\xff\xff\x00", 4);
202 			i++;
203 			break;
204 		case TNL_GRETAP:
205 			list[i].h_u.nvgre_hdr.tni_flow = fltr->tenant_id;
206 			memcpy(&list[i].m_u.nvgre_hdr.tni_flow,
207 			       "\xff\xff\xff\xff", 4);
208 			i++;
209 			break;
210 		case TNL_GTPC:
211 		case TNL_GTPU:
212 			list[i].h_u.gtp_hdr.teid = fltr->tenant_id;
213 			memcpy(&list[i].m_u.gtp_hdr.teid,
214 			       "\xff\xff\xff\xff", 4);
215 			i++;
216 			break;
217 		default:
218 			break;
219 		}
220 	}
221 
222 	if (flags & ICE_TC_FLWR_FIELD_ENC_DST_MAC) {
223 		list[i].type = ice_proto_type_from_mac(false);
224 		ether_addr_copy(list[i].h_u.eth_hdr.dst_addr,
225 				hdr->l2_key.dst_mac);
226 		ether_addr_copy(list[i].m_u.eth_hdr.dst_addr,
227 				hdr->l2_mask.dst_mac);
228 		i++;
229 	}
230 
231 	if (flags & ICE_TC_FLWR_FIELD_GTP_OPTS) {
232 		list[i].type = ice_proto_type_from_tunnel(fltr->tunnel_type);
233 
234 		if (fltr->gtp_pdu_info_masks.pdu_type) {
235 			list[i].h_u.gtp_hdr.pdu_type =
236 				fltr->gtp_pdu_info_keys.pdu_type << 4;
237 			memcpy(&list[i].m_u.gtp_hdr.pdu_type, "\xf0", 1);
238 		}
239 
240 		if (fltr->gtp_pdu_info_masks.qfi) {
241 			list[i].h_u.gtp_hdr.qfi = fltr->gtp_pdu_info_keys.qfi;
242 			memcpy(&list[i].m_u.gtp_hdr.qfi, "\x3f", 1);
243 		}
244 
245 		i++;
246 	}
247 
248 	if (flags & ICE_TC_FLWR_FIELD_PFCP_OPTS) {
249 		struct ice_pfcp_hdr *hdr_h, *hdr_m;
250 
251 		hdr_h = &list[i].h_u.pfcp_hdr;
252 		hdr_m = &list[i].m_u.pfcp_hdr;
253 		list[i].type = ICE_PFCP;
254 
255 		hdr_h->flags = fltr->pfcp_meta_keys.type;
256 		hdr_m->flags = fltr->pfcp_meta_masks.type & 0x01;
257 
258 		hdr_h->seid = fltr->pfcp_meta_keys.seid;
259 		hdr_m->seid = fltr->pfcp_meta_masks.seid;
260 
261 		i++;
262 	}
263 
264 	if (flags & (ICE_TC_FLWR_FIELD_ENC_SRC_IPV4 |
265 		     ICE_TC_FLWR_FIELD_ENC_DEST_IPV4)) {
266 		list[i].type = ice_proto_type_from_ipv4(false);
267 
268 		if (flags & ICE_TC_FLWR_FIELD_ENC_SRC_IPV4) {
269 			list[i].h_u.ipv4_hdr.src_addr = hdr->l3_key.src_ipv4;
270 			list[i].m_u.ipv4_hdr.src_addr = hdr->l3_mask.src_ipv4;
271 		}
272 		if (flags & ICE_TC_FLWR_FIELD_ENC_DEST_IPV4) {
273 			list[i].h_u.ipv4_hdr.dst_addr = hdr->l3_key.dst_ipv4;
274 			list[i].m_u.ipv4_hdr.dst_addr = hdr->l3_mask.dst_ipv4;
275 		}
276 		i++;
277 	}
278 
279 	if (flags & (ICE_TC_FLWR_FIELD_ENC_SRC_IPV6 |
280 		     ICE_TC_FLWR_FIELD_ENC_DEST_IPV6)) {
281 		list[i].type = ice_proto_type_from_ipv6(false);
282 
283 		if (flags & ICE_TC_FLWR_FIELD_ENC_SRC_IPV6) {
284 			memcpy(&list[i].h_u.ipv6_hdr.src_addr,
285 			       &hdr->l3_key.src_ipv6_addr,
286 			       sizeof(hdr->l3_key.src_ipv6_addr));
287 			memcpy(&list[i].m_u.ipv6_hdr.src_addr,
288 			       &hdr->l3_mask.src_ipv6_addr,
289 			       sizeof(hdr->l3_mask.src_ipv6_addr));
290 		}
291 		if (flags & ICE_TC_FLWR_FIELD_ENC_DEST_IPV6) {
292 			memcpy(&list[i].h_u.ipv6_hdr.dst_addr,
293 			       &hdr->l3_key.dst_ipv6_addr,
294 			       sizeof(hdr->l3_key.dst_ipv6_addr));
295 			memcpy(&list[i].m_u.ipv6_hdr.dst_addr,
296 			       &hdr->l3_mask.dst_ipv6_addr,
297 			       sizeof(hdr->l3_mask.dst_ipv6_addr));
298 		}
299 		i++;
300 	}
301 
302 	if (fltr->inner_headers.l2_key.n_proto == htons(ETH_P_IP) &&
303 	    (flags & (ICE_TC_FLWR_FIELD_ENC_IP_TOS |
304 		      ICE_TC_FLWR_FIELD_ENC_IP_TTL))) {
305 		list[i].type = ice_proto_type_from_ipv4(false);
306 
307 		if (flags & ICE_TC_FLWR_FIELD_ENC_IP_TOS) {
308 			list[i].h_u.ipv4_hdr.tos = hdr->l3_key.tos;
309 			list[i].m_u.ipv4_hdr.tos = hdr->l3_mask.tos;
310 		}
311 
312 		if (flags & ICE_TC_FLWR_FIELD_ENC_IP_TTL) {
313 			list[i].h_u.ipv4_hdr.time_to_live = hdr->l3_key.ttl;
314 			list[i].m_u.ipv4_hdr.time_to_live = hdr->l3_mask.ttl;
315 		}
316 
317 		i++;
318 	}
319 
320 	if (fltr->inner_headers.l2_key.n_proto == htons(ETH_P_IPV6) &&
321 	    (flags & (ICE_TC_FLWR_FIELD_ENC_IP_TOS |
322 		      ICE_TC_FLWR_FIELD_ENC_IP_TTL))) {
323 		struct ice_ipv6_hdr *hdr_h, *hdr_m;
324 
325 		hdr_h = &list[i].h_u.ipv6_hdr;
326 		hdr_m = &list[i].m_u.ipv6_hdr;
327 		list[i].type = ice_proto_type_from_ipv6(false);
328 
329 		if (flags & ICE_TC_FLWR_FIELD_ENC_IP_TOS) {
330 			be32p_replace_bits(&hdr_h->be_ver_tc_flow,
331 					   hdr->l3_key.tos,
332 					   ICE_IPV6_HDR_TC_MASK);
333 			be32p_replace_bits(&hdr_m->be_ver_tc_flow,
334 					   hdr->l3_mask.tos,
335 					   ICE_IPV6_HDR_TC_MASK);
336 		}
337 
338 		if (flags & ICE_TC_FLWR_FIELD_ENC_IP_TTL) {
339 			hdr_h->hop_limit = hdr->l3_key.ttl;
340 			hdr_m->hop_limit = hdr->l3_mask.ttl;
341 		}
342 
343 		i++;
344 	}
345 
346 	if ((flags & ICE_TC_FLWR_FIELD_ENC_DEST_L4_PORT) &&
347 	    hdr->l3_key.ip_proto == IPPROTO_UDP) {
348 		list[i].type = ICE_UDP_OF;
349 		list[i].h_u.l4_hdr.dst_port = hdr->l4_key.dst_port;
350 		list[i].m_u.l4_hdr.dst_port = hdr->l4_mask.dst_port;
351 		i++;
352 	}
353 
354 	/* always fill matching on tunneled packets in metadata */
355 	ice_rule_add_tunnel_metadata(&list[ICE_TC_METADATA_LKUP_IDX]);
356 
357 	return i;
358 }
359 
360 /**
361  * ice_tc_fill_rules - fill filter rules based on TC fltr
362  * @hw: pointer to HW structure
363  * @flags: tc flower field flags
364  * @tc_fltr: pointer to TC flower filter
365  * @list: list of advance rule elements
366  * @rule_info: pointer to information about rule
367  * @l4_proto: pointer to information such as L4 proto type
368  *
369  * Fill ice_adv_lkup_elem list based on TC flower flags and
370  * TC flower headers. This list should be used to add
371  * advance filter in hardware.
372  */
373 static int
374 ice_tc_fill_rules(struct ice_hw *hw, u32 flags,
375 		  struct ice_tc_flower_fltr *tc_fltr,
376 		  struct ice_adv_lkup_elem *list,
377 		  struct ice_adv_rule_info *rule_info,
378 		  u16 *l4_proto)
379 {
380 	struct ice_tc_flower_lyr_2_4_hdrs *headers = &tc_fltr->outer_headers;
381 	bool inner = false;
382 	u16 vlan_tpid = 0;
383 	int i = 1; /* 0th lookup is metadata */
384 
385 	rule_info->vlan_type = vlan_tpid;
386 
387 	/* Always add direction metadata */
388 	ice_rule_add_direction_metadata(&list[ICE_TC_METADATA_LKUP_IDX]);
389 
390 	if (tc_fltr->direction == ICE_ESWITCH_FLTR_EGRESS) {
391 		ice_rule_add_src_vsi_metadata(&list[i]);
392 		i++;
393 	}
394 
395 	rule_info->tun_type = ice_sw_type_from_tunnel(tc_fltr->tunnel_type);
396 	if (tc_fltr->tunnel_type != TNL_LAST) {
397 		i = ice_tc_fill_tunnel_outer(flags, tc_fltr, list, i);
398 
399 		/* PFCP is considered non-tunneled - don't swap headers. */
400 		if (tc_fltr->tunnel_type != TNL_PFCP) {
401 			headers = &tc_fltr->inner_headers;
402 			inner = true;
403 		}
404 	}
405 
406 	if (flags & ICE_TC_FLWR_FIELD_ETH_TYPE_ID) {
407 		list[i].type = ice_proto_type_from_etype(inner);
408 		list[i].h_u.ethertype.ethtype_id = headers->l2_key.n_proto;
409 		list[i].m_u.ethertype.ethtype_id = headers->l2_mask.n_proto;
410 		i++;
411 	}
412 
413 	if (flags & (ICE_TC_FLWR_FIELD_DST_MAC |
414 		     ICE_TC_FLWR_FIELD_SRC_MAC)) {
415 		struct ice_tc_l2_hdr *l2_key, *l2_mask;
416 
417 		l2_key = &headers->l2_key;
418 		l2_mask = &headers->l2_mask;
419 
420 		list[i].type = ice_proto_type_from_mac(inner);
421 		if (flags & ICE_TC_FLWR_FIELD_DST_MAC) {
422 			ether_addr_copy(list[i].h_u.eth_hdr.dst_addr,
423 					l2_key->dst_mac);
424 			ether_addr_copy(list[i].m_u.eth_hdr.dst_addr,
425 					l2_mask->dst_mac);
426 		}
427 		if (flags & ICE_TC_FLWR_FIELD_SRC_MAC) {
428 			ether_addr_copy(list[i].h_u.eth_hdr.src_addr,
429 					l2_key->src_mac);
430 			ether_addr_copy(list[i].m_u.eth_hdr.src_addr,
431 					l2_mask->src_mac);
432 		}
433 		i++;
434 	}
435 
436 	/* copy VLAN info */
437 	if (flags & (ICE_TC_FLWR_FIELD_VLAN | ICE_TC_FLWR_FIELD_VLAN_PRIO)) {
438 		if (flags & ICE_TC_FLWR_FIELD_CVLAN)
439 			list[i].type = ICE_VLAN_EX;
440 		else
441 			list[i].type = ICE_VLAN_OFOS;
442 
443 		if (flags & ICE_TC_FLWR_FIELD_VLAN) {
444 			list[i].h_u.vlan_hdr.vlan = headers->vlan_hdr.vlan_id;
445 			list[i].m_u.vlan_hdr.vlan = cpu_to_be16(0x0FFF);
446 		}
447 
448 		if (flags & ICE_TC_FLWR_FIELD_VLAN_PRIO) {
449 			if (flags & ICE_TC_FLWR_FIELD_VLAN) {
450 				list[i].m_u.vlan_hdr.vlan = cpu_to_be16(0xEFFF);
451 			} else {
452 				list[i].m_u.vlan_hdr.vlan = cpu_to_be16(0xE000);
453 				list[i].h_u.vlan_hdr.vlan = 0;
454 			}
455 			list[i].h_u.vlan_hdr.vlan |=
456 				headers->vlan_hdr.vlan_prio;
457 		}
458 
459 		i++;
460 	}
461 
462 	if (flags & ICE_TC_FLWR_FIELD_VLAN_TPID) {
463 		vlan_tpid = be16_to_cpu(headers->vlan_hdr.vlan_tpid);
464 		rule_info->vlan_type =
465 				ice_check_supported_vlan_tpid(vlan_tpid);
466 
467 		ice_rule_add_vlan_metadata(&list[ICE_TC_METADATA_LKUP_IDX]);
468 	}
469 
470 	if (flags & (ICE_TC_FLWR_FIELD_CVLAN | ICE_TC_FLWR_FIELD_CVLAN_PRIO)) {
471 		list[i].type = ICE_VLAN_IN;
472 
473 		if (flags & ICE_TC_FLWR_FIELD_CVLAN) {
474 			list[i].h_u.vlan_hdr.vlan = headers->cvlan_hdr.vlan_id;
475 			list[i].m_u.vlan_hdr.vlan = cpu_to_be16(0x0FFF);
476 		}
477 
478 		if (flags & ICE_TC_FLWR_FIELD_CVLAN_PRIO) {
479 			if (flags & ICE_TC_FLWR_FIELD_CVLAN) {
480 				list[i].m_u.vlan_hdr.vlan = cpu_to_be16(0xEFFF);
481 			} else {
482 				list[i].m_u.vlan_hdr.vlan = cpu_to_be16(0xE000);
483 				list[i].h_u.vlan_hdr.vlan = 0;
484 			}
485 			list[i].h_u.vlan_hdr.vlan |=
486 				headers->cvlan_hdr.vlan_prio;
487 		}
488 
489 		i++;
490 	}
491 
492 	if (flags & (ICE_TC_FLWR_FIELD_PPPOE_SESSID |
493 		     ICE_TC_FLWR_FIELD_PPP_PROTO)) {
494 		struct ice_pppoe_hdr *vals, *masks;
495 
496 		vals = &list[i].h_u.pppoe_hdr;
497 		masks = &list[i].m_u.pppoe_hdr;
498 
499 		list[i].type = ICE_PPPOE;
500 
501 		if (flags & ICE_TC_FLWR_FIELD_PPPOE_SESSID) {
502 			vals->session_id = headers->pppoe_hdr.session_id;
503 			masks->session_id = cpu_to_be16(0xFFFF);
504 		}
505 
506 		if (flags & ICE_TC_FLWR_FIELD_PPP_PROTO) {
507 			vals->ppp_prot_id = headers->pppoe_hdr.ppp_proto;
508 			masks->ppp_prot_id = cpu_to_be16(0xFFFF);
509 		}
510 
511 		i++;
512 	}
513 
514 	/* copy L3 (IPv[4|6]: src, dest) address */
515 	if (flags & (ICE_TC_FLWR_FIELD_DEST_IPV4 |
516 		     ICE_TC_FLWR_FIELD_SRC_IPV4)) {
517 		struct ice_tc_l3_hdr *l3_key, *l3_mask;
518 
519 		list[i].type = ice_proto_type_from_ipv4(inner);
520 		l3_key = &headers->l3_key;
521 		l3_mask = &headers->l3_mask;
522 		if (flags & ICE_TC_FLWR_FIELD_DEST_IPV4) {
523 			list[i].h_u.ipv4_hdr.dst_addr = l3_key->dst_ipv4;
524 			list[i].m_u.ipv4_hdr.dst_addr = l3_mask->dst_ipv4;
525 		}
526 		if (flags & ICE_TC_FLWR_FIELD_SRC_IPV4) {
527 			list[i].h_u.ipv4_hdr.src_addr = l3_key->src_ipv4;
528 			list[i].m_u.ipv4_hdr.src_addr = l3_mask->src_ipv4;
529 		}
530 		i++;
531 	} else if (flags & (ICE_TC_FLWR_FIELD_DEST_IPV6 |
532 			    ICE_TC_FLWR_FIELD_SRC_IPV6)) {
533 		struct ice_ipv6_hdr *ipv6_hdr, *ipv6_mask;
534 		struct ice_tc_l3_hdr *l3_key, *l3_mask;
535 
536 		list[i].type = ice_proto_type_from_ipv6(inner);
537 		ipv6_hdr = &list[i].h_u.ipv6_hdr;
538 		ipv6_mask = &list[i].m_u.ipv6_hdr;
539 		l3_key = &headers->l3_key;
540 		l3_mask = &headers->l3_mask;
541 
542 		if (flags & ICE_TC_FLWR_FIELD_DEST_IPV6) {
543 			memcpy(&ipv6_hdr->dst_addr, &l3_key->dst_ipv6_addr,
544 			       sizeof(l3_key->dst_ipv6_addr));
545 			memcpy(&ipv6_mask->dst_addr, &l3_mask->dst_ipv6_addr,
546 			       sizeof(l3_mask->dst_ipv6_addr));
547 		}
548 		if (flags & ICE_TC_FLWR_FIELD_SRC_IPV6) {
549 			memcpy(&ipv6_hdr->src_addr, &l3_key->src_ipv6_addr,
550 			       sizeof(l3_key->src_ipv6_addr));
551 			memcpy(&ipv6_mask->src_addr, &l3_mask->src_ipv6_addr,
552 			       sizeof(l3_mask->src_ipv6_addr));
553 		}
554 		i++;
555 	}
556 
557 	if (headers->l2_key.n_proto == htons(ETH_P_IP) &&
558 	    (flags & (ICE_TC_FLWR_FIELD_IP_TOS | ICE_TC_FLWR_FIELD_IP_TTL))) {
559 		list[i].type = ice_proto_type_from_ipv4(inner);
560 
561 		if (flags & ICE_TC_FLWR_FIELD_IP_TOS) {
562 			list[i].h_u.ipv4_hdr.tos = headers->l3_key.tos;
563 			list[i].m_u.ipv4_hdr.tos = headers->l3_mask.tos;
564 		}
565 
566 		if (flags & ICE_TC_FLWR_FIELD_IP_TTL) {
567 			list[i].h_u.ipv4_hdr.time_to_live =
568 				headers->l3_key.ttl;
569 			list[i].m_u.ipv4_hdr.time_to_live =
570 				headers->l3_mask.ttl;
571 		}
572 
573 		i++;
574 	}
575 
576 	if (headers->l2_key.n_proto == htons(ETH_P_IPV6) &&
577 	    (flags & (ICE_TC_FLWR_FIELD_IP_TOS | ICE_TC_FLWR_FIELD_IP_TTL))) {
578 		struct ice_ipv6_hdr *hdr_h, *hdr_m;
579 
580 		hdr_h = &list[i].h_u.ipv6_hdr;
581 		hdr_m = &list[i].m_u.ipv6_hdr;
582 		list[i].type = ice_proto_type_from_ipv6(inner);
583 
584 		if (flags & ICE_TC_FLWR_FIELD_IP_TOS) {
585 			be32p_replace_bits(&hdr_h->be_ver_tc_flow,
586 					   headers->l3_key.tos,
587 					   ICE_IPV6_HDR_TC_MASK);
588 			be32p_replace_bits(&hdr_m->be_ver_tc_flow,
589 					   headers->l3_mask.tos,
590 					   ICE_IPV6_HDR_TC_MASK);
591 		}
592 
593 		if (flags & ICE_TC_FLWR_FIELD_IP_TTL) {
594 			hdr_h->hop_limit = headers->l3_key.ttl;
595 			hdr_m->hop_limit = headers->l3_mask.ttl;
596 		}
597 
598 		i++;
599 	}
600 
601 	if (flags & ICE_TC_FLWR_FIELD_L2TPV3_SESSID) {
602 		list[i].type = ICE_L2TPV3;
603 
604 		list[i].h_u.l2tpv3_sess_hdr.session_id =
605 			headers->l2tpv3_hdr.session_id;
606 		list[i].m_u.l2tpv3_sess_hdr.session_id =
607 			cpu_to_be32(0xFFFFFFFF);
608 
609 		i++;
610 	}
611 
612 	/* copy L4 (src, dest) port */
613 	if (flags & (ICE_TC_FLWR_FIELD_DEST_L4_PORT |
614 		     ICE_TC_FLWR_FIELD_SRC_L4_PORT)) {
615 		struct ice_tc_l4_hdr *l4_key, *l4_mask;
616 
617 		list[i].type = ice_proto_type_from_l4_port(headers->l3_key.ip_proto);
618 		l4_key = &headers->l4_key;
619 		l4_mask = &headers->l4_mask;
620 
621 		if (flags & ICE_TC_FLWR_FIELD_DEST_L4_PORT) {
622 			list[i].h_u.l4_hdr.dst_port = l4_key->dst_port;
623 			list[i].m_u.l4_hdr.dst_port = l4_mask->dst_port;
624 		}
625 		if (flags & ICE_TC_FLWR_FIELD_SRC_L4_PORT) {
626 			list[i].h_u.l4_hdr.src_port = l4_key->src_port;
627 			list[i].m_u.l4_hdr.src_port = l4_mask->src_port;
628 		}
629 		i++;
630 	}
631 
632 	return i;
633 }
634 
635 /**
636  * ice_tc_tun_get_type - get the tunnel type
637  * @tunnel_dev: ptr to tunnel device
638  *
639  * This function detects appropriate tunnel_type if specified device is
640  * tunnel device such as VXLAN/Geneve
641  */
642 static int ice_tc_tun_get_type(struct net_device *tunnel_dev)
643 {
644 	if (netif_is_vxlan(tunnel_dev))
645 		return TNL_VXLAN;
646 	if (netif_is_geneve(tunnel_dev))
647 		return TNL_GENEVE;
648 	if (netif_is_gretap(tunnel_dev) ||
649 	    netif_is_ip6gretap(tunnel_dev))
650 		return TNL_GRETAP;
651 
652 	/* Assume GTP-U by default in case of GTP netdev.
653 	 * GTP-C may be selected later, based on enc_dst_port.
654 	 */
655 	if (netif_is_gtp(tunnel_dev))
656 		return TNL_GTPU;
657 	if (netif_is_pfcp(tunnel_dev))
658 		return TNL_PFCP;
659 	return TNL_LAST;
660 }
661 
662 bool ice_is_tunnel_supported(struct net_device *dev)
663 {
664 	return ice_tc_tun_get_type(dev) != TNL_LAST;
665 }
666 
667 static bool ice_tc_is_dev_uplink(struct net_device *dev)
668 {
669 	return netif_is_ice(dev) || ice_is_tunnel_supported(dev);
670 }
671 
672 static int ice_tc_setup_action(struct net_device *filter_dev,
673 			       struct ice_tc_flower_fltr *fltr,
674 			       struct net_device *target_dev,
675 			       enum ice_sw_fwd_act_type action)
676 {
677 	struct ice_repr *repr;
678 
679 	if (action != ICE_FWD_TO_VSI && action != ICE_MIRROR_PACKET) {
680 		NL_SET_ERR_MSG_MOD(fltr->extack, "Unsupported action to setup provided");
681 		return -EINVAL;
682 	}
683 
684 	fltr->action.fltr_act = action;
685 
686 	if (ice_is_port_repr_netdev(filter_dev) &&
687 	    ice_is_port_repr_netdev(target_dev)) {
688 		repr = ice_netdev_to_repr(target_dev);
689 
690 		fltr->dest_vsi = repr->src_vsi;
691 		fltr->direction = ICE_ESWITCH_FLTR_EGRESS;
692 	} else if (ice_is_port_repr_netdev(filter_dev) &&
693 		   ice_tc_is_dev_uplink(target_dev)) {
694 		repr = ice_netdev_to_repr(filter_dev);
695 
696 		fltr->dest_vsi = repr->src_vsi->back->eswitch.uplink_vsi;
697 		fltr->direction = ICE_ESWITCH_FLTR_EGRESS;
698 	} else if (ice_tc_is_dev_uplink(filter_dev) &&
699 		   ice_is_port_repr_netdev(target_dev)) {
700 		repr = ice_netdev_to_repr(target_dev);
701 
702 		fltr->dest_vsi = repr->src_vsi;
703 		fltr->direction = ICE_ESWITCH_FLTR_INGRESS;
704 	} else {
705 		NL_SET_ERR_MSG_MOD(fltr->extack,
706 				   "Unsupported netdevice in switchdev mode");
707 		return -EINVAL;
708 	}
709 
710 	return 0;
711 }
712 
713 static int
714 ice_tc_setup_drop_action(struct net_device *filter_dev,
715 			 struct ice_tc_flower_fltr *fltr)
716 {
717 	fltr->action.fltr_act = ICE_DROP_PACKET;
718 
719 	if (ice_is_port_repr_netdev(filter_dev)) {
720 		fltr->direction = ICE_ESWITCH_FLTR_EGRESS;
721 	} else if (ice_tc_is_dev_uplink(filter_dev)) {
722 		fltr->direction = ICE_ESWITCH_FLTR_INGRESS;
723 	} else {
724 		NL_SET_ERR_MSG_MOD(fltr->extack,
725 				   "Unsupported netdevice in switchdev mode");
726 		return -EINVAL;
727 	}
728 
729 	return 0;
730 }
731 
732 static int ice_eswitch_tc_parse_action(struct net_device *filter_dev,
733 				       struct ice_tc_flower_fltr *fltr,
734 				       struct flow_action_entry *act)
735 {
736 	int err;
737 
738 	switch (act->id) {
739 	case FLOW_ACTION_DROP:
740 		err = ice_tc_setup_drop_action(filter_dev, fltr);
741 		if (err)
742 			return err;
743 
744 		break;
745 
746 	case FLOW_ACTION_REDIRECT:
747 		err = ice_tc_setup_action(filter_dev, fltr,
748 					  act->dev, ICE_FWD_TO_VSI);
749 		if (err)
750 			return err;
751 
752 		break;
753 
754 	case FLOW_ACTION_MIRRED:
755 		err = ice_tc_setup_action(filter_dev, fltr,
756 					  act->dev, ICE_MIRROR_PACKET);
757 		if (err)
758 			return err;
759 
760 		break;
761 
762 	default:
763 		NL_SET_ERR_MSG_MOD(fltr->extack, "Unsupported action in switchdev mode");
764 		return -EINVAL;
765 	}
766 
767 	return 0;
768 }
769 
770 static int
771 ice_eswitch_add_tc_fltr(struct ice_vsi *vsi, struct ice_tc_flower_fltr *fltr)
772 {
773 	struct ice_tc_flower_lyr_2_4_hdrs *headers = &fltr->outer_headers;
774 	struct ice_adv_rule_info rule_info = { 0 };
775 	struct ice_rule_query_data rule_added;
776 	struct ice_hw *hw = &vsi->back->hw;
777 	struct ice_adv_lkup_elem *list;
778 	u32 flags = fltr->flags;
779 	int lkups_cnt;
780 	int ret;
781 	int i;
782 
783 	if (flags & ICE_TC_FLWR_FIELD_ENC_SRC_L4_PORT) {
784 		NL_SET_ERR_MSG_MOD(fltr->extack, "Unsupported encap field(s)");
785 		return -EOPNOTSUPP;
786 	}
787 
788 	lkups_cnt = ice_tc_count_lkups(flags, headers, fltr);
789 	list = kcalloc(lkups_cnt, sizeof(*list), GFP_ATOMIC);
790 	if (!list)
791 		return -ENOMEM;
792 
793 	i = ice_tc_fill_rules(hw, flags, fltr, list, &rule_info, NULL);
794 	if (i != lkups_cnt) {
795 		ret = -EINVAL;
796 		goto exit;
797 	}
798 
799 	rule_info.sw_act.fltr_act = fltr->action.fltr_act;
800 	if (fltr->action.fltr_act != ICE_DROP_PACKET)
801 		rule_info.sw_act.vsi_handle = fltr->dest_vsi->idx;
802 	/* For now, making priority to be highest, and it also becomes
803 	 * the priority for recipe which will get created as a result of
804 	 * new extraction sequence based on input set.
805 	 * Priority '7' is max val for switch recipe, higher the number
806 	 * results into order of switch rule evaluation.
807 	 */
808 	rule_info.priority = 7;
809 	rule_info.flags_info.act_valid = true;
810 
811 	if (fltr->direction == ICE_ESWITCH_FLTR_INGRESS) {
812 		/* Uplink to VF */
813 		rule_info.sw_act.flag |= ICE_FLTR_RX;
814 		rule_info.sw_act.src = hw->pf_id;
815 		rule_info.flags_info.act = ICE_SINGLE_ACT_LB_ENABLE;
816 	} else if (fltr->direction == ICE_ESWITCH_FLTR_EGRESS &&
817 		   fltr->dest_vsi == vsi->back->eswitch.uplink_vsi) {
818 		/* VF to Uplink */
819 		rule_info.sw_act.flag |= ICE_FLTR_TX;
820 		rule_info.sw_act.src = vsi->idx;
821 		rule_info.flags_info.act = ICE_SINGLE_ACT_LAN_ENABLE;
822 	} else {
823 		/* VF to VF */
824 		rule_info.sw_act.flag |= ICE_FLTR_TX;
825 		rule_info.sw_act.src = vsi->idx;
826 		rule_info.flags_info.act = ICE_SINGLE_ACT_LB_ENABLE;
827 	}
828 
829 	/* specify the cookie as filter_rule_id */
830 	rule_info.fltr_rule_id = fltr->cookie;
831 	rule_info.src_vsi = vsi->idx;
832 
833 	ret = ice_add_adv_rule(hw, list, lkups_cnt, &rule_info, &rule_added);
834 	if (ret == -EEXIST) {
835 		NL_SET_ERR_MSG_MOD(fltr->extack, "Unable to add filter because it already exist");
836 		ret = -EINVAL;
837 		goto exit;
838 	} else if (ret) {
839 		NL_SET_ERR_MSG_MOD(fltr->extack, "Unable to add filter due to error");
840 		goto exit;
841 	}
842 
843 	/* store the output params, which are needed later for removing
844 	 * advanced switch filter
845 	 */
846 	fltr->rid = rule_added.rid;
847 	fltr->rule_id = rule_added.rule_id;
848 	fltr->dest_vsi_handle = rule_added.vsi_handle;
849 
850 exit:
851 	kfree(list);
852 	return ret;
853 }
854 
855 /**
856  * ice_locate_vsi_using_queue - locate VSI using queue (forward to queue action)
857  * @vsi: Pointer to VSI
858  * @queue: Queue index
859  *
860  * Locate the VSI using specified "queue". When ADQ is not enabled,
861  * always return input VSI, otherwise locate corresponding
862  * VSI based on per channel "offset" and "qcount"
863  */
864 struct ice_vsi *
865 ice_locate_vsi_using_queue(struct ice_vsi *vsi, int queue)
866 {
867 	int num_tc, tc;
868 
869 	/* if ADQ is not active, passed VSI is the candidate VSI */
870 	if (!ice_is_adq_active(vsi->back))
871 		return vsi;
872 
873 	/* Locate the VSI (it could still be main PF VSI or CHNL_VSI depending
874 	 * upon queue number)
875 	 */
876 	num_tc = vsi->mqprio_qopt.qopt.num_tc;
877 
878 	for (tc = 0; tc < num_tc; tc++) {
879 		int qcount = vsi->mqprio_qopt.qopt.count[tc];
880 		int offset = vsi->mqprio_qopt.qopt.offset[tc];
881 
882 		if (queue >= offset && queue < offset + qcount) {
883 			/* for non-ADQ TCs, passed VSI is the candidate VSI */
884 			if (tc < ICE_CHNL_START_TC)
885 				return vsi;
886 			else
887 				return vsi->tc_map_vsi[tc];
888 		}
889 	}
890 	return NULL;
891 }
892 
893 static struct ice_rx_ring *
894 ice_locate_rx_ring_using_queue(struct ice_vsi *vsi,
895 			       struct ice_tc_flower_fltr *tc_fltr)
896 {
897 	u16 queue = tc_fltr->action.fwd.q.queue;
898 
899 	return queue < vsi->num_rxq ? vsi->rx_rings[queue] : NULL;
900 }
901 
902 /**
903  * ice_tc_forward_action - Determine destination VSI and queue for the action
904  * @vsi: Pointer to VSI
905  * @tc_fltr: Pointer to TC flower filter structure
906  *
907  * Validates the tc forward action and determines the destination VSI and queue
908  * for the forward action.
909  */
910 static struct ice_vsi *
911 ice_tc_forward_action(struct ice_vsi *vsi, struct ice_tc_flower_fltr *tc_fltr)
912 {
913 	struct ice_rx_ring *ring = NULL;
914 	struct ice_vsi *dest_vsi = NULL;
915 	struct ice_pf *pf = vsi->back;
916 	struct device *dev;
917 	u32 tc_class;
918 	int q;
919 
920 	dev = ice_pf_to_dev(pf);
921 
922 	/* Get the destination VSI and/or destination queue and validate them */
923 	switch (tc_fltr->action.fltr_act) {
924 	case ICE_FWD_TO_VSI:
925 		tc_class = tc_fltr->action.fwd.tc.tc_class;
926 		/* Select the destination VSI */
927 		if (tc_class < ICE_CHNL_START_TC) {
928 			NL_SET_ERR_MSG_MOD(tc_fltr->extack,
929 					   "Unable to add filter because of unsupported destination");
930 			return ERR_PTR(-EOPNOTSUPP);
931 		}
932 		/* Locate ADQ VSI depending on hw_tc number */
933 		dest_vsi = vsi->tc_map_vsi[tc_class];
934 		break;
935 	case ICE_FWD_TO_Q:
936 		/* Locate the Rx queue */
937 		ring = ice_locate_rx_ring_using_queue(vsi, tc_fltr);
938 		if (!ring) {
939 			dev_err(dev,
940 				"Unable to locate Rx queue for action fwd_to_queue: %u\n",
941 				tc_fltr->action.fwd.q.queue);
942 			return ERR_PTR(-EINVAL);
943 		}
944 		/* Determine destination VSI even though the action is
945 		 * FWD_TO_QUEUE, because QUEUE is associated with VSI
946 		 */
947 		q = tc_fltr->action.fwd.q.queue;
948 		dest_vsi = ice_locate_vsi_using_queue(vsi, q);
949 		break;
950 	default:
951 		dev_err(dev,
952 			"Unable to add filter because of unsupported action %u (supported actions: fwd to tc, fwd to queue)\n",
953 			tc_fltr->action.fltr_act);
954 		return ERR_PTR(-EINVAL);
955 	}
956 	/* Must have valid dest_vsi (it could be main VSI or ADQ VSI) */
957 	if (!dest_vsi) {
958 		dev_err(dev,
959 			"Unable to add filter because specified destination VSI doesn't exist\n");
960 		return ERR_PTR(-EINVAL);
961 	}
962 	return dest_vsi;
963 }
964 
965 /**
966  * ice_add_tc_flower_adv_fltr - add appropriate filter rules
967  * @vsi: Pointer to VSI
968  * @tc_fltr: Pointer to TC flower filter structure
969  *
970  * based on filter parameters using Advance recipes supported
971  * by OS package.
972  */
973 static int
974 ice_add_tc_flower_adv_fltr(struct ice_vsi *vsi,
975 			   struct ice_tc_flower_fltr *tc_fltr)
976 {
977 	struct ice_tc_flower_lyr_2_4_hdrs *headers = &tc_fltr->outer_headers;
978 	struct ice_adv_rule_info rule_info = {0};
979 	struct ice_rule_query_data rule_added;
980 	struct ice_adv_lkup_elem *list;
981 	struct ice_pf *pf = vsi->back;
982 	struct ice_hw *hw = &pf->hw;
983 	u32 flags = tc_fltr->flags;
984 	struct ice_vsi *dest_vsi;
985 	struct device *dev;
986 	u16 lkups_cnt = 0;
987 	u16 l4_proto = 0;
988 	int ret = 0;
989 	u16 i = 0;
990 
991 	dev = ice_pf_to_dev(pf);
992 	if (ice_is_safe_mode(pf)) {
993 		NL_SET_ERR_MSG_MOD(tc_fltr->extack, "Unable to add filter because driver is in safe mode");
994 		return -EOPNOTSUPP;
995 	}
996 
997 	if (!flags || (flags & (ICE_TC_FLWR_FIELD_ENC_DEST_IPV4 |
998 				ICE_TC_FLWR_FIELD_ENC_SRC_IPV4 |
999 				ICE_TC_FLWR_FIELD_ENC_DEST_IPV6 |
1000 				ICE_TC_FLWR_FIELD_ENC_SRC_IPV6 |
1001 				ICE_TC_FLWR_FIELD_ENC_SRC_L4_PORT))) {
1002 		NL_SET_ERR_MSG_MOD(tc_fltr->extack, "Unsupported encap field(s)");
1003 		return -EOPNOTSUPP;
1004 	}
1005 
1006 	/* validate forwarding action VSI and queue */
1007 	if (ice_is_forward_action(tc_fltr->action.fltr_act)) {
1008 		dest_vsi = ice_tc_forward_action(vsi, tc_fltr);
1009 		if (IS_ERR(dest_vsi))
1010 			return PTR_ERR(dest_vsi);
1011 	}
1012 
1013 	lkups_cnt = ice_tc_count_lkups(flags, headers, tc_fltr);
1014 	list = kcalloc(lkups_cnt, sizeof(*list), GFP_ATOMIC);
1015 	if (!list)
1016 		return -ENOMEM;
1017 
1018 	i = ice_tc_fill_rules(hw, flags, tc_fltr, list, &rule_info, &l4_proto);
1019 	if (i != lkups_cnt) {
1020 		ret = -EINVAL;
1021 		goto exit;
1022 	}
1023 
1024 	rule_info.sw_act.fltr_act = tc_fltr->action.fltr_act;
1025 	/* specify the cookie as filter_rule_id */
1026 	rule_info.fltr_rule_id = tc_fltr->cookie;
1027 
1028 	switch (tc_fltr->action.fltr_act) {
1029 	case ICE_FWD_TO_VSI:
1030 		rule_info.sw_act.vsi_handle = dest_vsi->idx;
1031 		rule_info.priority = ICE_SWITCH_FLTR_PRIO_VSI;
1032 		rule_info.sw_act.src = hw->pf_id;
1033 		dev_dbg(dev, "add switch rule for TC:%u vsi_idx:%u, lkups_cnt:%u\n",
1034 			tc_fltr->action.fwd.tc.tc_class,
1035 			rule_info.sw_act.vsi_handle, lkups_cnt);
1036 		break;
1037 	case ICE_FWD_TO_Q:
1038 		/* HW queue number in global space */
1039 		rule_info.sw_act.fwd_id.q_id = tc_fltr->action.fwd.q.hw_queue;
1040 		rule_info.sw_act.vsi_handle = dest_vsi->idx;
1041 		rule_info.priority = ICE_SWITCH_FLTR_PRIO_QUEUE;
1042 		rule_info.sw_act.src = hw->pf_id;
1043 		dev_dbg(dev, "add switch rule action to forward to queue:%u (HW queue %u), lkups_cnt:%u\n",
1044 			tc_fltr->action.fwd.q.queue,
1045 			tc_fltr->action.fwd.q.hw_queue, lkups_cnt);
1046 		break;
1047 	case ICE_DROP_PACKET:
1048 		rule_info.sw_act.flag |= ICE_FLTR_RX;
1049 		rule_info.sw_act.src = hw->pf_id;
1050 		rule_info.priority = ICE_SWITCH_FLTR_PRIO_VSI;
1051 		break;
1052 	default:
1053 		ret = -EOPNOTSUPP;
1054 		goto exit;
1055 	}
1056 
1057 	ret = ice_add_adv_rule(hw, list, lkups_cnt, &rule_info, &rule_added);
1058 	if (ret == -EEXIST) {
1059 		NL_SET_ERR_MSG_MOD(tc_fltr->extack,
1060 				   "Unable to add filter because it already exist");
1061 		ret = -EINVAL;
1062 		goto exit;
1063 	} else if (ret) {
1064 		NL_SET_ERR_MSG_MOD(tc_fltr->extack,
1065 				   "Unable to add filter due to error");
1066 		goto exit;
1067 	}
1068 
1069 	/* store the output params, which are needed later for removing
1070 	 * advanced switch filter
1071 	 */
1072 	tc_fltr->rid = rule_added.rid;
1073 	tc_fltr->rule_id = rule_added.rule_id;
1074 	tc_fltr->dest_vsi_handle = rule_added.vsi_handle;
1075 	if (tc_fltr->action.fltr_act == ICE_FWD_TO_VSI ||
1076 	    tc_fltr->action.fltr_act == ICE_FWD_TO_Q) {
1077 		tc_fltr->dest_vsi = dest_vsi;
1078 		/* keep track of advanced switch filter for
1079 		 * destination VSI
1080 		 */
1081 		dest_vsi->num_chnl_fltr++;
1082 
1083 		/* keeps track of channel filters for PF VSI */
1084 		if (vsi->type == ICE_VSI_PF &&
1085 		    (flags & (ICE_TC_FLWR_FIELD_DST_MAC |
1086 			      ICE_TC_FLWR_FIELD_ENC_DST_MAC)))
1087 			pf->num_dmac_chnl_fltrs++;
1088 	}
1089 	switch (tc_fltr->action.fltr_act) {
1090 	case ICE_FWD_TO_VSI:
1091 		dev_dbg(dev, "added switch rule (lkups_cnt %u, flags 0x%x), action is forward to TC %u, rid %u, rule_id %u, vsi_idx %u\n",
1092 			lkups_cnt, flags,
1093 			tc_fltr->action.fwd.tc.tc_class, rule_added.rid,
1094 			rule_added.rule_id, rule_added.vsi_handle);
1095 		break;
1096 	case ICE_FWD_TO_Q:
1097 		dev_dbg(dev, "added switch rule (lkups_cnt %u, flags 0x%x), action is forward to queue: %u (HW queue %u)     , rid %u, rule_id %u\n",
1098 			lkups_cnt, flags, tc_fltr->action.fwd.q.queue,
1099 			tc_fltr->action.fwd.q.hw_queue, rule_added.rid,
1100 			rule_added.rule_id);
1101 		break;
1102 	case ICE_DROP_PACKET:
1103 		dev_dbg(dev, "added switch rule (lkups_cnt %u, flags 0x%x), action is drop, rid %u, rule_id %u\n",
1104 			lkups_cnt, flags, rule_added.rid, rule_added.rule_id);
1105 		break;
1106 	default:
1107 		break;
1108 	}
1109 exit:
1110 	kfree(list);
1111 	return ret;
1112 }
1113 
1114 /**
1115  * ice_tc_set_pppoe - Parse PPPoE fields from TC flower filter
1116  * @match: Pointer to flow match structure
1117  * @fltr: Pointer to filter structure
1118  * @headers: Pointer to outer header fields
1119  * @returns PPP protocol used in filter (ppp_ses or ppp_disc)
1120  */
1121 static u16
1122 ice_tc_set_pppoe(struct flow_match_pppoe *match,
1123 		 struct ice_tc_flower_fltr *fltr,
1124 		 struct ice_tc_flower_lyr_2_4_hdrs *headers)
1125 {
1126 	if (match->mask->session_id) {
1127 		fltr->flags |= ICE_TC_FLWR_FIELD_PPPOE_SESSID;
1128 		headers->pppoe_hdr.session_id = match->key->session_id;
1129 	}
1130 
1131 	if (match->mask->ppp_proto) {
1132 		fltr->flags |= ICE_TC_FLWR_FIELD_PPP_PROTO;
1133 		headers->pppoe_hdr.ppp_proto = match->key->ppp_proto;
1134 	}
1135 
1136 	return be16_to_cpu(match->key->type);
1137 }
1138 
1139 /**
1140  * ice_tc_set_ipv4 - Parse IPv4 addresses from TC flower filter
1141  * @match: Pointer to flow match structure
1142  * @fltr: Pointer to filter structure
1143  * @headers: inner or outer header fields
1144  * @is_encap: set true for tunnel IPv4 address
1145  */
1146 static int
1147 ice_tc_set_ipv4(struct flow_match_ipv4_addrs *match,
1148 		struct ice_tc_flower_fltr *fltr,
1149 		struct ice_tc_flower_lyr_2_4_hdrs *headers, bool is_encap)
1150 {
1151 	if (match->key->dst) {
1152 		if (is_encap)
1153 			fltr->flags |= ICE_TC_FLWR_FIELD_ENC_DEST_IPV4;
1154 		else
1155 			fltr->flags |= ICE_TC_FLWR_FIELD_DEST_IPV4;
1156 		headers->l3_key.dst_ipv4 = match->key->dst;
1157 		headers->l3_mask.dst_ipv4 = match->mask->dst;
1158 	}
1159 	if (match->key->src) {
1160 		if (is_encap)
1161 			fltr->flags |= ICE_TC_FLWR_FIELD_ENC_SRC_IPV4;
1162 		else
1163 			fltr->flags |= ICE_TC_FLWR_FIELD_SRC_IPV4;
1164 		headers->l3_key.src_ipv4 = match->key->src;
1165 		headers->l3_mask.src_ipv4 = match->mask->src;
1166 	}
1167 	return 0;
1168 }
1169 
1170 /**
1171  * ice_tc_set_ipv6 - Parse IPv6 addresses from TC flower filter
1172  * @match: Pointer to flow match structure
1173  * @fltr: Pointer to filter structure
1174  * @headers: inner or outer header fields
1175  * @is_encap: set true for tunnel IPv6 address
1176  */
1177 static int
1178 ice_tc_set_ipv6(struct flow_match_ipv6_addrs *match,
1179 		struct ice_tc_flower_fltr *fltr,
1180 		struct ice_tc_flower_lyr_2_4_hdrs *headers, bool is_encap)
1181 {
1182 	struct ice_tc_l3_hdr *l3_key, *l3_mask;
1183 
1184 	/* src and dest IPV6 address should not be LOOPBACK
1185 	 * (0:0:0:0:0:0:0:1), which can be represented as ::1
1186 	 */
1187 	if (ipv6_addr_loopback(&match->key->dst) ||
1188 	    ipv6_addr_loopback(&match->key->src)) {
1189 		NL_SET_ERR_MSG_MOD(fltr->extack, "Bad IPv6, addr is LOOPBACK");
1190 		return -EINVAL;
1191 	}
1192 	/* if src/dest IPv6 address is *,* error */
1193 	if (ipv6_addr_any(&match->mask->dst) &&
1194 	    ipv6_addr_any(&match->mask->src)) {
1195 		NL_SET_ERR_MSG_MOD(fltr->extack, "Bad src/dest IPv6, addr is any");
1196 		return -EINVAL;
1197 	}
1198 	if (!ipv6_addr_any(&match->mask->dst)) {
1199 		if (is_encap)
1200 			fltr->flags |= ICE_TC_FLWR_FIELD_ENC_DEST_IPV6;
1201 		else
1202 			fltr->flags |= ICE_TC_FLWR_FIELD_DEST_IPV6;
1203 	}
1204 	if (!ipv6_addr_any(&match->mask->src)) {
1205 		if (is_encap)
1206 			fltr->flags |= ICE_TC_FLWR_FIELD_ENC_SRC_IPV6;
1207 		else
1208 			fltr->flags |= ICE_TC_FLWR_FIELD_SRC_IPV6;
1209 	}
1210 
1211 	l3_key = &headers->l3_key;
1212 	l3_mask = &headers->l3_mask;
1213 
1214 	if (fltr->flags & (ICE_TC_FLWR_FIELD_ENC_SRC_IPV6 |
1215 			   ICE_TC_FLWR_FIELD_SRC_IPV6)) {
1216 		memcpy(&l3_key->src_ipv6_addr, &match->key->src.s6_addr,
1217 		       sizeof(match->key->src.s6_addr));
1218 		memcpy(&l3_mask->src_ipv6_addr, &match->mask->src.s6_addr,
1219 		       sizeof(match->mask->src.s6_addr));
1220 	}
1221 	if (fltr->flags & (ICE_TC_FLWR_FIELD_ENC_DEST_IPV6 |
1222 			   ICE_TC_FLWR_FIELD_DEST_IPV6)) {
1223 		memcpy(&l3_key->dst_ipv6_addr, &match->key->dst.s6_addr,
1224 		       sizeof(match->key->dst.s6_addr));
1225 		memcpy(&l3_mask->dst_ipv6_addr, &match->mask->dst.s6_addr,
1226 		       sizeof(match->mask->dst.s6_addr));
1227 	}
1228 
1229 	return 0;
1230 }
1231 
1232 /**
1233  * ice_tc_set_tos_ttl - Parse IP ToS/TTL from TC flower filter
1234  * @match: Pointer to flow match structure
1235  * @fltr: Pointer to filter structure
1236  * @headers: inner or outer header fields
1237  * @is_encap: set true for tunnel
1238  */
1239 static void
1240 ice_tc_set_tos_ttl(struct flow_match_ip *match,
1241 		   struct ice_tc_flower_fltr *fltr,
1242 		   struct ice_tc_flower_lyr_2_4_hdrs *headers,
1243 		   bool is_encap)
1244 {
1245 	if (match->mask->tos) {
1246 		if (is_encap)
1247 			fltr->flags |= ICE_TC_FLWR_FIELD_ENC_IP_TOS;
1248 		else
1249 			fltr->flags |= ICE_TC_FLWR_FIELD_IP_TOS;
1250 
1251 		headers->l3_key.tos = match->key->tos;
1252 		headers->l3_mask.tos = match->mask->tos;
1253 	}
1254 
1255 	if (match->mask->ttl) {
1256 		if (is_encap)
1257 			fltr->flags |= ICE_TC_FLWR_FIELD_ENC_IP_TTL;
1258 		else
1259 			fltr->flags |= ICE_TC_FLWR_FIELD_IP_TTL;
1260 
1261 		headers->l3_key.ttl = match->key->ttl;
1262 		headers->l3_mask.ttl = match->mask->ttl;
1263 	}
1264 }
1265 
1266 /**
1267  * ice_tc_set_port - Parse ports from TC flower filter
1268  * @match: Flow match structure
1269  * @fltr: Pointer to filter structure
1270  * @headers: inner or outer header fields
1271  * @is_encap: set true for tunnel port
1272  */
1273 static int
1274 ice_tc_set_port(struct flow_match_ports match,
1275 		struct ice_tc_flower_fltr *fltr,
1276 		struct ice_tc_flower_lyr_2_4_hdrs *headers, bool is_encap)
1277 {
1278 	if (match.key->dst) {
1279 		if (is_encap)
1280 			fltr->flags |= ICE_TC_FLWR_FIELD_ENC_DEST_L4_PORT;
1281 		else
1282 			fltr->flags |= ICE_TC_FLWR_FIELD_DEST_L4_PORT;
1283 
1284 		headers->l4_key.dst_port = match.key->dst;
1285 		headers->l4_mask.dst_port = match.mask->dst;
1286 	}
1287 	if (match.key->src) {
1288 		if (is_encap)
1289 			fltr->flags |= ICE_TC_FLWR_FIELD_ENC_SRC_L4_PORT;
1290 		else
1291 			fltr->flags |= ICE_TC_FLWR_FIELD_SRC_L4_PORT;
1292 
1293 		headers->l4_key.src_port = match.key->src;
1294 		headers->l4_mask.src_port = match.mask->src;
1295 	}
1296 	return 0;
1297 }
1298 
1299 static struct net_device *
1300 ice_get_tunnel_device(struct net_device *dev, struct flow_rule *rule)
1301 {
1302 	struct flow_action_entry *act;
1303 	int i;
1304 
1305 	if (ice_is_tunnel_supported(dev))
1306 		return dev;
1307 
1308 	flow_action_for_each(i, act, &rule->action) {
1309 		if (act->id == FLOW_ACTION_REDIRECT &&
1310 		    ice_is_tunnel_supported(act->dev))
1311 			return act->dev;
1312 	}
1313 
1314 	return NULL;
1315 }
1316 
1317 /**
1318  * ice_parse_gtp_type - Sets GTP tunnel type to GTP-U or GTP-C
1319  * @match: Flow match structure
1320  * @fltr: Pointer to filter structure
1321  *
1322  * GTP-C/GTP-U is selected based on destination port number (enc_dst_port).
1323  * Before calling this funtcion, fltr->tunnel_type should be set to TNL_GTPU,
1324  * therefore making GTP-U the default choice (when destination port number is
1325  * not specified).
1326  */
1327 static int
1328 ice_parse_gtp_type(struct flow_match_ports match,
1329 		   struct ice_tc_flower_fltr *fltr)
1330 {
1331 	u16 dst_port;
1332 
1333 	if (match.key->dst) {
1334 		dst_port = be16_to_cpu(match.key->dst);
1335 
1336 		switch (dst_port) {
1337 		case 2152:
1338 			break;
1339 		case 2123:
1340 			fltr->tunnel_type = TNL_GTPC;
1341 			break;
1342 		default:
1343 			NL_SET_ERR_MSG_MOD(fltr->extack, "Unsupported GTP port number");
1344 			return -EINVAL;
1345 		}
1346 	}
1347 
1348 	return 0;
1349 }
1350 
1351 static int
1352 ice_parse_tunnel_attr(struct net_device *dev, struct flow_rule *rule,
1353 		      struct ice_tc_flower_fltr *fltr)
1354 {
1355 	struct ice_tc_flower_lyr_2_4_hdrs *headers = &fltr->outer_headers;
1356 	struct flow_match_control enc_control;
1357 
1358 	fltr->tunnel_type = ice_tc_tun_get_type(dev);
1359 	headers->l3_key.ip_proto = IPPROTO_UDP;
1360 
1361 	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_KEYID)) {
1362 		struct flow_match_enc_keyid enc_keyid;
1363 
1364 		flow_rule_match_enc_keyid(rule, &enc_keyid);
1365 
1366 		if (!enc_keyid.mask->keyid ||
1367 		    enc_keyid.mask->keyid != cpu_to_be32(ICE_TC_FLOWER_MASK_32))
1368 			return -EINVAL;
1369 
1370 		fltr->flags |= ICE_TC_FLWR_FIELD_TENANT_ID;
1371 		fltr->tenant_id = enc_keyid.key->keyid;
1372 	}
1373 
1374 	flow_rule_match_enc_control(rule, &enc_control);
1375 
1376 	if (enc_control.key->addr_type == FLOW_DISSECTOR_KEY_IPV4_ADDRS) {
1377 		struct flow_match_ipv4_addrs match;
1378 
1379 		flow_rule_match_enc_ipv4_addrs(rule, &match);
1380 		if (ice_tc_set_ipv4(&match, fltr, headers, true))
1381 			return -EINVAL;
1382 	} else if (enc_control.key->addr_type ==
1383 					FLOW_DISSECTOR_KEY_IPV6_ADDRS) {
1384 		struct flow_match_ipv6_addrs match;
1385 
1386 		flow_rule_match_enc_ipv6_addrs(rule, &match);
1387 		if (ice_tc_set_ipv6(&match, fltr, headers, true))
1388 			return -EINVAL;
1389 	}
1390 
1391 	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_IP)) {
1392 		struct flow_match_ip match;
1393 
1394 		flow_rule_match_enc_ip(rule, &match);
1395 		ice_tc_set_tos_ttl(&match, fltr, headers, true);
1396 	}
1397 
1398 	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_PORTS) &&
1399 	    fltr->tunnel_type != TNL_VXLAN && fltr->tunnel_type != TNL_GENEVE) {
1400 		struct flow_match_ports match;
1401 
1402 		flow_rule_match_enc_ports(rule, &match);
1403 
1404 		if (fltr->tunnel_type != TNL_GTPU) {
1405 			if (ice_tc_set_port(match, fltr, headers, true))
1406 				return -EINVAL;
1407 		} else {
1408 			if (ice_parse_gtp_type(match, fltr))
1409 				return -EINVAL;
1410 		}
1411 	}
1412 
1413 	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_OPTS) &&
1414 	    (fltr->tunnel_type == TNL_GTPU || fltr->tunnel_type == TNL_GTPC)) {
1415 		struct flow_match_enc_opts match;
1416 
1417 		flow_rule_match_enc_opts(rule, &match);
1418 
1419 		memcpy(&fltr->gtp_pdu_info_keys, &match.key->data[0],
1420 		       sizeof(struct gtp_pdu_session_info));
1421 
1422 		memcpy(&fltr->gtp_pdu_info_masks, &match.mask->data[0],
1423 		       sizeof(struct gtp_pdu_session_info));
1424 
1425 		fltr->flags |= ICE_TC_FLWR_FIELD_GTP_OPTS;
1426 	}
1427 
1428 	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_OPTS) &&
1429 	    fltr->tunnel_type == TNL_PFCP) {
1430 		struct flow_match_enc_opts match;
1431 
1432 		flow_rule_match_enc_opts(rule, &match);
1433 
1434 		memcpy(&fltr->pfcp_meta_keys, match.key->data,
1435 		       sizeof(struct pfcp_metadata));
1436 		memcpy(&fltr->pfcp_meta_masks, match.mask->data,
1437 		       sizeof(struct pfcp_metadata));
1438 
1439 		fltr->flags |= ICE_TC_FLWR_FIELD_PFCP_OPTS;
1440 	}
1441 
1442 	return 0;
1443 }
1444 
1445 /**
1446  * ice_parse_cls_flower - Parse TC flower filters provided by kernel
1447  * @vsi: Pointer to the VSI
1448  * @filter_dev: Pointer to device on which filter is being added
1449  * @f: Pointer to struct flow_cls_offload
1450  * @fltr: Pointer to filter structure
1451  */
1452 static int
1453 ice_parse_cls_flower(struct net_device *filter_dev, struct ice_vsi *vsi,
1454 		     struct flow_cls_offload *f,
1455 		     struct ice_tc_flower_fltr *fltr)
1456 {
1457 	struct ice_tc_flower_lyr_2_4_hdrs *headers = &fltr->outer_headers;
1458 	struct flow_rule *rule = flow_cls_offload_flow_rule(f);
1459 	u16 n_proto_mask = 0, n_proto_key = 0, addr_type = 0;
1460 	struct flow_dissector *dissector;
1461 	struct net_device *tunnel_dev;
1462 
1463 	dissector = rule->match.dissector;
1464 
1465 	if (dissector->used_keys &
1466 	    ~(BIT_ULL(FLOW_DISSECTOR_KEY_CONTROL) |
1467 	      BIT_ULL(FLOW_DISSECTOR_KEY_BASIC) |
1468 	      BIT_ULL(FLOW_DISSECTOR_KEY_ETH_ADDRS) |
1469 	      BIT_ULL(FLOW_DISSECTOR_KEY_VLAN) |
1470 	      BIT_ULL(FLOW_DISSECTOR_KEY_CVLAN) |
1471 	      BIT_ULL(FLOW_DISSECTOR_KEY_IPV4_ADDRS) |
1472 	      BIT_ULL(FLOW_DISSECTOR_KEY_IPV6_ADDRS) |
1473 	      BIT_ULL(FLOW_DISSECTOR_KEY_ENC_CONTROL) |
1474 	      BIT_ULL(FLOW_DISSECTOR_KEY_ENC_KEYID) |
1475 	      BIT_ULL(FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS) |
1476 	      BIT_ULL(FLOW_DISSECTOR_KEY_ENC_IPV6_ADDRS) |
1477 	      BIT_ULL(FLOW_DISSECTOR_KEY_ENC_PORTS) |
1478 	      BIT_ULL(FLOW_DISSECTOR_KEY_ENC_OPTS) |
1479 	      BIT_ULL(FLOW_DISSECTOR_KEY_IP) |
1480 	      BIT_ULL(FLOW_DISSECTOR_KEY_ENC_IP) |
1481 	      BIT_ULL(FLOW_DISSECTOR_KEY_PORTS) |
1482 	      BIT_ULL(FLOW_DISSECTOR_KEY_PPPOE) |
1483 	      BIT_ULL(FLOW_DISSECTOR_KEY_L2TPV3))) {
1484 		NL_SET_ERR_MSG_MOD(fltr->extack, "Unsupported key used");
1485 		return -EOPNOTSUPP;
1486 	}
1487 
1488 	tunnel_dev = ice_get_tunnel_device(filter_dev, rule);
1489 	if (tunnel_dev) {
1490 		int err;
1491 
1492 		filter_dev = tunnel_dev;
1493 
1494 		err = ice_parse_tunnel_attr(filter_dev, rule, fltr);
1495 		if (err) {
1496 			NL_SET_ERR_MSG_MOD(fltr->extack, "Failed to parse TC flower tunnel attributes");
1497 			return err;
1498 		}
1499 
1500 		/* PFCP is considered non-tunneled - don't swap headers. */
1501 		if (fltr->tunnel_type != TNL_PFCP) {
1502 			/* Header pointers should point to the inner headers,
1503 			 * outer header were already set by
1504 			 * ice_parse_tunnel_attr().
1505 			 */
1506 			headers = &fltr->inner_headers;
1507 		}
1508 	} else if (dissector->used_keys &
1509 		  (BIT_ULL(FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS) |
1510 		   BIT_ULL(FLOW_DISSECTOR_KEY_ENC_IPV6_ADDRS) |
1511 		   BIT_ULL(FLOW_DISSECTOR_KEY_ENC_KEYID) |
1512 		   BIT_ULL(FLOW_DISSECTOR_KEY_ENC_PORTS) |
1513 		   BIT_ULL(FLOW_DISSECTOR_KEY_ENC_IP) |
1514 		   BIT_ULL(FLOW_DISSECTOR_KEY_ENC_OPTS) |
1515 		   BIT_ULL(FLOW_DISSECTOR_KEY_ENC_CONTROL))) {
1516 		NL_SET_ERR_MSG_MOD(fltr->extack, "Tunnel key used, but device isn't a tunnel");
1517 		return -EOPNOTSUPP;
1518 	} else {
1519 		fltr->tunnel_type = TNL_LAST;
1520 	}
1521 
1522 	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_BASIC)) {
1523 		struct flow_match_basic match;
1524 
1525 		flow_rule_match_basic(rule, &match);
1526 
1527 		n_proto_key = ntohs(match.key->n_proto);
1528 		n_proto_mask = ntohs(match.mask->n_proto);
1529 
1530 		if (n_proto_key == ETH_P_ALL || n_proto_key == 0 ||
1531 		    fltr->tunnel_type == TNL_GTPU ||
1532 		    fltr->tunnel_type == TNL_GTPC) {
1533 			n_proto_key = 0;
1534 			n_proto_mask = 0;
1535 		} else {
1536 			fltr->flags |= ICE_TC_FLWR_FIELD_ETH_TYPE_ID;
1537 		}
1538 
1539 		headers->l2_key.n_proto = cpu_to_be16(n_proto_key);
1540 		headers->l2_mask.n_proto = cpu_to_be16(n_proto_mask);
1541 		headers->l3_key.ip_proto = match.key->ip_proto;
1542 	}
1543 
1544 	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ETH_ADDRS)) {
1545 		struct flow_match_eth_addrs match;
1546 
1547 		flow_rule_match_eth_addrs(rule, &match);
1548 
1549 		if (!is_zero_ether_addr(match.key->dst)) {
1550 			ether_addr_copy(headers->l2_key.dst_mac,
1551 					match.key->dst);
1552 			ether_addr_copy(headers->l2_mask.dst_mac,
1553 					match.mask->dst);
1554 			fltr->flags |= ICE_TC_FLWR_FIELD_DST_MAC;
1555 		}
1556 
1557 		if (!is_zero_ether_addr(match.key->src)) {
1558 			ether_addr_copy(headers->l2_key.src_mac,
1559 					match.key->src);
1560 			ether_addr_copy(headers->l2_mask.src_mac,
1561 					match.mask->src);
1562 			fltr->flags |= ICE_TC_FLWR_FIELD_SRC_MAC;
1563 		}
1564 	}
1565 
1566 	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_VLAN) ||
1567 	    is_vlan_dev(filter_dev)) {
1568 		struct flow_dissector_key_vlan mask;
1569 		struct flow_dissector_key_vlan key;
1570 		struct flow_match_vlan match;
1571 
1572 		if (is_vlan_dev(filter_dev)) {
1573 			match.key = &key;
1574 			match.key->vlan_id = vlan_dev_vlan_id(filter_dev);
1575 			match.key->vlan_priority = 0;
1576 			match.mask = &mask;
1577 			memset(match.mask, 0xff, sizeof(*match.mask));
1578 			match.mask->vlan_priority = 0;
1579 		} else {
1580 			flow_rule_match_vlan(rule, &match);
1581 		}
1582 
1583 		if (match.mask->vlan_id) {
1584 			if (match.mask->vlan_id == VLAN_VID_MASK) {
1585 				fltr->flags |= ICE_TC_FLWR_FIELD_VLAN;
1586 				headers->vlan_hdr.vlan_id =
1587 					cpu_to_be16(match.key->vlan_id &
1588 						    VLAN_VID_MASK);
1589 			} else {
1590 				NL_SET_ERR_MSG_MOD(fltr->extack, "Bad VLAN mask");
1591 				return -EINVAL;
1592 			}
1593 		}
1594 
1595 		if (match.mask->vlan_priority) {
1596 			fltr->flags |= ICE_TC_FLWR_FIELD_VLAN_PRIO;
1597 			headers->vlan_hdr.vlan_prio =
1598 				be16_encode_bits(match.key->vlan_priority,
1599 						 VLAN_PRIO_MASK);
1600 		}
1601 
1602 		if (match.mask->vlan_tpid) {
1603 			headers->vlan_hdr.vlan_tpid = match.key->vlan_tpid;
1604 			fltr->flags |= ICE_TC_FLWR_FIELD_VLAN_TPID;
1605 		}
1606 	}
1607 
1608 	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_CVLAN)) {
1609 		struct flow_match_vlan match;
1610 
1611 		if (!ice_is_dvm_ena(&vsi->back->hw)) {
1612 			NL_SET_ERR_MSG_MOD(fltr->extack, "Double VLAN mode is not enabled");
1613 			return -EINVAL;
1614 		}
1615 
1616 		flow_rule_match_cvlan(rule, &match);
1617 
1618 		if (match.mask->vlan_id) {
1619 			if (match.mask->vlan_id == VLAN_VID_MASK) {
1620 				fltr->flags |= ICE_TC_FLWR_FIELD_CVLAN;
1621 				headers->cvlan_hdr.vlan_id =
1622 					cpu_to_be16(match.key->vlan_id &
1623 						    VLAN_VID_MASK);
1624 			} else {
1625 				NL_SET_ERR_MSG_MOD(fltr->extack,
1626 						   "Bad CVLAN mask");
1627 				return -EINVAL;
1628 			}
1629 		}
1630 
1631 		if (match.mask->vlan_priority) {
1632 			fltr->flags |= ICE_TC_FLWR_FIELD_CVLAN_PRIO;
1633 			headers->cvlan_hdr.vlan_prio =
1634 				be16_encode_bits(match.key->vlan_priority,
1635 						 VLAN_PRIO_MASK);
1636 		}
1637 	}
1638 
1639 	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_PPPOE)) {
1640 		struct flow_match_pppoe match;
1641 
1642 		flow_rule_match_pppoe(rule, &match);
1643 		n_proto_key = ice_tc_set_pppoe(&match, fltr, headers);
1644 
1645 		/* If ethertype equals ETH_P_PPP_SES, n_proto might be
1646 		 * overwritten by encapsulated protocol (ppp_proto field) or set
1647 		 * to 0. To correct this, flow_match_pppoe provides the type
1648 		 * field, which contains the actual ethertype (ETH_P_PPP_SES).
1649 		 */
1650 		headers->l2_key.n_proto = cpu_to_be16(n_proto_key);
1651 		headers->l2_mask.n_proto = cpu_to_be16(0xFFFF);
1652 		fltr->flags |= ICE_TC_FLWR_FIELD_ETH_TYPE_ID;
1653 	}
1654 
1655 	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_CONTROL)) {
1656 		struct flow_match_control match;
1657 
1658 		flow_rule_match_control(rule, &match);
1659 
1660 		addr_type = match.key->addr_type;
1661 
1662 		if (flow_rule_has_control_flags(match.mask->flags,
1663 						fltr->extack))
1664 			return -EOPNOTSUPP;
1665 	}
1666 
1667 	if (addr_type == FLOW_DISSECTOR_KEY_IPV4_ADDRS) {
1668 		struct flow_match_ipv4_addrs match;
1669 
1670 		flow_rule_match_ipv4_addrs(rule, &match);
1671 		if (ice_tc_set_ipv4(&match, fltr, headers, false))
1672 			return -EINVAL;
1673 	}
1674 
1675 	if (addr_type == FLOW_DISSECTOR_KEY_IPV6_ADDRS) {
1676 		struct flow_match_ipv6_addrs match;
1677 
1678 		flow_rule_match_ipv6_addrs(rule, &match);
1679 		if (ice_tc_set_ipv6(&match, fltr, headers, false))
1680 			return -EINVAL;
1681 	}
1682 
1683 	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_IP)) {
1684 		struct flow_match_ip match;
1685 
1686 		flow_rule_match_ip(rule, &match);
1687 		ice_tc_set_tos_ttl(&match, fltr, headers, false);
1688 	}
1689 
1690 	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_L2TPV3)) {
1691 		struct flow_match_l2tpv3 match;
1692 
1693 		flow_rule_match_l2tpv3(rule, &match);
1694 
1695 		fltr->flags |= ICE_TC_FLWR_FIELD_L2TPV3_SESSID;
1696 		headers->l2tpv3_hdr.session_id = match.key->session_id;
1697 	}
1698 
1699 	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_PORTS)) {
1700 		struct flow_match_ports match;
1701 
1702 		flow_rule_match_ports(rule, &match);
1703 		if (ice_tc_set_port(match, fltr, headers, false))
1704 			return -EINVAL;
1705 		switch (headers->l3_key.ip_proto) {
1706 		case IPPROTO_TCP:
1707 		case IPPROTO_UDP:
1708 			break;
1709 		default:
1710 			NL_SET_ERR_MSG_MOD(fltr->extack, "Only UDP and TCP transport are supported");
1711 			return -EINVAL;
1712 		}
1713 	}
1714 	return 0;
1715 }
1716 
1717 /**
1718  * ice_add_switch_fltr - Add TC flower filters
1719  * @vsi: Pointer to VSI
1720  * @fltr: Pointer to struct ice_tc_flower_fltr
1721  *
1722  * Add filter in HW switch block
1723  */
1724 static int
1725 ice_add_switch_fltr(struct ice_vsi *vsi, struct ice_tc_flower_fltr *fltr)
1726 {
1727 	if (fltr->action.fltr_act == ICE_FWD_TO_QGRP)
1728 		return -EOPNOTSUPP;
1729 
1730 	if (ice_is_eswitch_mode_switchdev(vsi->back))
1731 		return ice_eswitch_add_tc_fltr(vsi, fltr);
1732 
1733 	return ice_add_tc_flower_adv_fltr(vsi, fltr);
1734 }
1735 
1736 /**
1737  * ice_prep_adq_filter - Prepare ADQ filter with the required additional headers
1738  * @vsi: Pointer to VSI
1739  * @fltr: Pointer to TC flower filter structure
1740  *
1741  * Prepare ADQ filter with the required additional header fields
1742  */
1743 static int
1744 ice_prep_adq_filter(struct ice_vsi *vsi, struct ice_tc_flower_fltr *fltr)
1745 {
1746 	if ((fltr->flags & ICE_TC_FLWR_FIELD_TENANT_ID) &&
1747 	    (fltr->flags & (ICE_TC_FLWR_FIELD_DST_MAC |
1748 			   ICE_TC_FLWR_FIELD_SRC_MAC))) {
1749 		NL_SET_ERR_MSG_MOD(fltr->extack,
1750 				   "Unable to add filter because filter using tunnel key and inner MAC is unsupported combination");
1751 		return -EOPNOTSUPP;
1752 	}
1753 
1754 	/* For ADQ, filter must include dest MAC address, otherwise unwanted
1755 	 * packets with unrelated MAC address get delivered to ADQ VSIs as long
1756 	 * as remaining filter criteria is satisfied such as dest IP address
1757 	 * and dest/src L4 port. Below code handles the following cases:
1758 	 * 1. For non-tunnel, if user specify MAC addresses, use them.
1759 	 * 2. For non-tunnel, if user didn't specify MAC address, add implicit
1760 	 * dest MAC to be lower netdev's active unicast MAC address
1761 	 * 3. For tunnel,  as of now TC-filter through flower classifier doesn't
1762 	 * have provision for user to specify outer DMAC, hence driver to
1763 	 * implicitly add outer dest MAC to be lower netdev's active unicast
1764 	 * MAC address.
1765 	 */
1766 	if (fltr->tunnel_type != TNL_LAST &&
1767 	    !(fltr->flags & ICE_TC_FLWR_FIELD_ENC_DST_MAC))
1768 		fltr->flags |= ICE_TC_FLWR_FIELD_ENC_DST_MAC;
1769 
1770 	if (fltr->tunnel_type == TNL_LAST &&
1771 	    !(fltr->flags & ICE_TC_FLWR_FIELD_DST_MAC))
1772 		fltr->flags |= ICE_TC_FLWR_FIELD_DST_MAC;
1773 
1774 	if (fltr->flags & (ICE_TC_FLWR_FIELD_DST_MAC |
1775 			   ICE_TC_FLWR_FIELD_ENC_DST_MAC)) {
1776 		ether_addr_copy(fltr->outer_headers.l2_key.dst_mac,
1777 				vsi->netdev->dev_addr);
1778 		eth_broadcast_addr(fltr->outer_headers.l2_mask.dst_mac);
1779 	}
1780 
1781 	/* Make sure VLAN is already added to main VSI, before allowing ADQ to
1782 	 * add a VLAN based filter such as MAC + VLAN + L4 port.
1783 	 */
1784 	if (fltr->flags & ICE_TC_FLWR_FIELD_VLAN) {
1785 		u16 vlan_id = be16_to_cpu(fltr->outer_headers.vlan_hdr.vlan_id);
1786 
1787 		if (!ice_vlan_fltr_exist(&vsi->back->hw, vlan_id, vsi->idx)) {
1788 			NL_SET_ERR_MSG_MOD(fltr->extack,
1789 					   "Unable to add filter because legacy VLAN filter for specified destination doesn't exist");
1790 			return -EINVAL;
1791 		}
1792 	}
1793 	return 0;
1794 }
1795 
1796 /**
1797  * ice_handle_tclass_action - Support directing to a traffic class
1798  * @vsi: Pointer to VSI
1799  * @cls_flower: Pointer to TC flower offload structure
1800  * @fltr: Pointer to TC flower filter structure
1801  *
1802  * Support directing traffic to a traffic class/queue-set
1803  */
1804 static int
1805 ice_handle_tclass_action(struct ice_vsi *vsi,
1806 			 struct flow_cls_offload *cls_flower,
1807 			 struct ice_tc_flower_fltr *fltr)
1808 {
1809 	int tc = tc_classid_to_hwtc(vsi->netdev, cls_flower->classid);
1810 
1811 	/* user specified hw_tc (must be non-zero for ADQ TC), action is forward
1812 	 * to hw_tc (i.e. ADQ channel number)
1813 	 */
1814 	if (tc < ICE_CHNL_START_TC) {
1815 		NL_SET_ERR_MSG_MOD(fltr->extack,
1816 				   "Unable to add filter because of unsupported destination");
1817 		return -EOPNOTSUPP;
1818 	}
1819 	if (!(vsi->all_enatc & BIT(tc))) {
1820 		NL_SET_ERR_MSG_MOD(fltr->extack,
1821 				   "Unable to add filter because of non-existence destination");
1822 		return -EINVAL;
1823 	}
1824 	fltr->action.fltr_act = ICE_FWD_TO_VSI;
1825 	fltr->action.fwd.tc.tc_class = tc;
1826 
1827 	return ice_prep_adq_filter(vsi, fltr);
1828 }
1829 
1830 static int
1831 ice_tc_forward_to_queue(struct ice_vsi *vsi, struct ice_tc_flower_fltr *fltr,
1832 			struct flow_action_entry *act)
1833 {
1834 	struct ice_vsi *ch_vsi = NULL;
1835 	u16 queue = act->rx_queue;
1836 
1837 	if (queue >= vsi->num_rxq) {
1838 		NL_SET_ERR_MSG_MOD(fltr->extack,
1839 				   "Unable to add filter because specified queue is invalid");
1840 		return -EINVAL;
1841 	}
1842 	fltr->action.fltr_act = ICE_FWD_TO_Q;
1843 	fltr->action.fwd.q.queue = queue;
1844 	/* determine corresponding HW queue */
1845 	fltr->action.fwd.q.hw_queue = vsi->rxq_map[queue];
1846 
1847 	/* If ADQ is configured, and the queue belongs to ADQ VSI, then prepare
1848 	 * ADQ switch filter
1849 	 */
1850 	ch_vsi = ice_locate_vsi_using_queue(vsi, fltr->action.fwd.q.queue);
1851 	if (!ch_vsi)
1852 		return -EINVAL;
1853 	fltr->dest_vsi = ch_vsi;
1854 	if (!ice_is_chnl_fltr(fltr))
1855 		return 0;
1856 
1857 	return ice_prep_adq_filter(vsi, fltr);
1858 }
1859 
1860 static int
1861 ice_tc_parse_action(struct ice_vsi *vsi, struct ice_tc_flower_fltr *fltr,
1862 		    struct flow_action_entry *act)
1863 {
1864 	switch (act->id) {
1865 	case FLOW_ACTION_RX_QUEUE_MAPPING:
1866 		/* forward to queue */
1867 		return ice_tc_forward_to_queue(vsi, fltr, act);
1868 	case FLOW_ACTION_DROP:
1869 		fltr->action.fltr_act = ICE_DROP_PACKET;
1870 		return 0;
1871 	default:
1872 		NL_SET_ERR_MSG_MOD(fltr->extack, "Unsupported TC action");
1873 		return -EOPNOTSUPP;
1874 	}
1875 }
1876 
1877 /**
1878  * ice_parse_tc_flower_actions - Parse the actions for a TC filter
1879  * @filter_dev: Pointer to device on which filter is being added
1880  * @vsi: Pointer to VSI
1881  * @cls_flower: Pointer to TC flower offload structure
1882  * @fltr: Pointer to TC flower filter structure
1883  *
1884  * Parse the actions for a TC filter
1885  */
1886 static int ice_parse_tc_flower_actions(struct net_device *filter_dev,
1887 				       struct ice_vsi *vsi,
1888 				       struct flow_cls_offload *cls_flower,
1889 				       struct ice_tc_flower_fltr *fltr)
1890 {
1891 	struct flow_rule *rule = flow_cls_offload_flow_rule(cls_flower);
1892 	struct flow_action *flow_action = &rule->action;
1893 	struct flow_action_entry *act;
1894 	int i, err;
1895 
1896 	if (cls_flower->classid)
1897 		return ice_handle_tclass_action(vsi, cls_flower, fltr);
1898 
1899 	if (!flow_action_has_entries(flow_action))
1900 		return -EINVAL;
1901 
1902 	flow_action_for_each(i, act, flow_action) {
1903 		if (ice_is_eswitch_mode_switchdev(vsi->back))
1904 			err = ice_eswitch_tc_parse_action(filter_dev, fltr, act);
1905 		else
1906 			err = ice_tc_parse_action(vsi, fltr, act);
1907 		if (err)
1908 			return err;
1909 		continue;
1910 	}
1911 	return 0;
1912 }
1913 
1914 /**
1915  * ice_del_tc_fltr - deletes a filter from HW table
1916  * @vsi: Pointer to VSI
1917  * @fltr: Pointer to struct ice_tc_flower_fltr
1918  *
1919  * This function deletes a filter from HW table and manages book-keeping
1920  */
1921 static int ice_del_tc_fltr(struct ice_vsi *vsi, struct ice_tc_flower_fltr *fltr)
1922 {
1923 	struct ice_rule_query_data rule_rem;
1924 	struct ice_pf *pf = vsi->back;
1925 	int err;
1926 
1927 	rule_rem.rid = fltr->rid;
1928 	rule_rem.rule_id = fltr->rule_id;
1929 	rule_rem.vsi_handle = fltr->dest_vsi_handle;
1930 	err = ice_rem_adv_rule_by_id(&pf->hw, &rule_rem);
1931 	if (err) {
1932 		if (err == -ENOENT) {
1933 			NL_SET_ERR_MSG_MOD(fltr->extack, "Filter does not exist");
1934 			return -ENOENT;
1935 		}
1936 		NL_SET_ERR_MSG_MOD(fltr->extack, "Failed to delete TC flower filter");
1937 		return -EIO;
1938 	}
1939 
1940 	/* update advanced switch filter count for destination
1941 	 * VSI if filter destination was VSI
1942 	 */
1943 	if (fltr->dest_vsi) {
1944 		if (fltr->dest_vsi->type == ICE_VSI_CHNL) {
1945 			fltr->dest_vsi->num_chnl_fltr--;
1946 
1947 			/* keeps track of channel filters for PF VSI */
1948 			if (vsi->type == ICE_VSI_PF &&
1949 			    (fltr->flags & (ICE_TC_FLWR_FIELD_DST_MAC |
1950 					    ICE_TC_FLWR_FIELD_ENC_DST_MAC)))
1951 				pf->num_dmac_chnl_fltrs--;
1952 		}
1953 	}
1954 	return 0;
1955 }
1956 
1957 /**
1958  * ice_add_tc_fltr - adds a TC flower filter
1959  * @netdev: Pointer to netdev
1960  * @vsi: Pointer to VSI
1961  * @f: Pointer to flower offload structure
1962  * @__fltr: Pointer to struct ice_tc_flower_fltr
1963  *
1964  * This function parses TC-flower input fields, parses action,
1965  * and adds a filter.
1966  */
1967 static int
1968 ice_add_tc_fltr(struct net_device *netdev, struct ice_vsi *vsi,
1969 		struct flow_cls_offload *f,
1970 		struct ice_tc_flower_fltr **__fltr)
1971 {
1972 	struct ice_tc_flower_fltr *fltr;
1973 	int err;
1974 
1975 	/* by default, set output to be INVALID */
1976 	*__fltr = NULL;
1977 
1978 	fltr = kzalloc(sizeof(*fltr), GFP_KERNEL);
1979 	if (!fltr)
1980 		return -ENOMEM;
1981 
1982 	fltr->cookie = f->cookie;
1983 	fltr->extack = f->common.extack;
1984 	fltr->src_vsi = vsi;
1985 	INIT_HLIST_NODE(&fltr->tc_flower_node);
1986 
1987 	err = ice_parse_cls_flower(netdev, vsi, f, fltr);
1988 	if (err < 0)
1989 		goto err;
1990 
1991 	err = ice_parse_tc_flower_actions(netdev, vsi, f, fltr);
1992 	if (err < 0)
1993 		goto err;
1994 
1995 	err = ice_add_switch_fltr(vsi, fltr);
1996 	if (err < 0)
1997 		goto err;
1998 
1999 	/* return the newly created filter */
2000 	*__fltr = fltr;
2001 
2002 	return 0;
2003 err:
2004 	kfree(fltr);
2005 	return err;
2006 }
2007 
2008 /**
2009  * ice_find_tc_flower_fltr - Find the TC flower filter in the list
2010  * @pf: Pointer to PF
2011  * @cookie: filter specific cookie
2012  */
2013 static struct ice_tc_flower_fltr *
2014 ice_find_tc_flower_fltr(struct ice_pf *pf, unsigned long cookie)
2015 {
2016 	struct ice_tc_flower_fltr *fltr;
2017 
2018 	hlist_for_each_entry(fltr, &pf->tc_flower_fltr_list, tc_flower_node)
2019 		if (cookie == fltr->cookie)
2020 			return fltr;
2021 
2022 	return NULL;
2023 }
2024 
2025 /**
2026  * ice_add_cls_flower - add TC flower filters
2027  * @netdev: Pointer to filter device
2028  * @vsi: Pointer to VSI
2029  * @cls_flower: Pointer to flower offload structure
2030  */
2031 int
2032 ice_add_cls_flower(struct net_device *netdev, struct ice_vsi *vsi,
2033 		   struct flow_cls_offload *cls_flower)
2034 {
2035 	struct netlink_ext_ack *extack = cls_flower->common.extack;
2036 	struct net_device *vsi_netdev = vsi->netdev;
2037 	struct ice_tc_flower_fltr *fltr;
2038 	struct ice_pf *pf = vsi->back;
2039 	int err;
2040 
2041 	if (ice_is_reset_in_progress(pf->state))
2042 		return -EBUSY;
2043 	if (test_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags))
2044 		return -EINVAL;
2045 
2046 	if (ice_is_port_repr_netdev(netdev))
2047 		vsi_netdev = netdev;
2048 
2049 	if (!(vsi_netdev->features & NETIF_F_HW_TC) &&
2050 	    !test_bit(ICE_FLAG_CLS_FLOWER, pf->flags)) {
2051 		/* Based on TC indirect notifications from kernel, all ice
2052 		 * devices get an instance of rule from higher level device.
2053 		 * Avoid triggering explicit error in this case.
2054 		 */
2055 		if (netdev == vsi_netdev)
2056 			NL_SET_ERR_MSG_MOD(extack, "can't apply TC flower filters, turn ON hw-tc-offload and try again");
2057 		return -EINVAL;
2058 	}
2059 
2060 	/* avoid duplicate entries, if exists - return error */
2061 	fltr = ice_find_tc_flower_fltr(pf, cls_flower->cookie);
2062 	if (fltr) {
2063 		NL_SET_ERR_MSG_MOD(extack, "filter cookie already exists, ignoring");
2064 		return -EEXIST;
2065 	}
2066 
2067 	/* prep and add TC-flower filter in HW */
2068 	err = ice_add_tc_fltr(netdev, vsi, cls_flower, &fltr);
2069 	if (err)
2070 		return err;
2071 
2072 	/* add filter into an ordered list */
2073 	hlist_add_head(&fltr->tc_flower_node, &pf->tc_flower_fltr_list);
2074 	return 0;
2075 }
2076 
2077 /**
2078  * ice_del_cls_flower - delete TC flower filters
2079  * @vsi: Pointer to VSI
2080  * @cls_flower: Pointer to struct flow_cls_offload
2081  */
2082 int
2083 ice_del_cls_flower(struct ice_vsi *vsi, struct flow_cls_offload *cls_flower)
2084 {
2085 	struct ice_tc_flower_fltr *fltr;
2086 	struct ice_pf *pf = vsi->back;
2087 	int err;
2088 
2089 	/* find filter */
2090 	fltr = ice_find_tc_flower_fltr(pf, cls_flower->cookie);
2091 	if (!fltr) {
2092 		if (!test_bit(ICE_FLAG_TC_MQPRIO, pf->flags) &&
2093 		    hlist_empty(&pf->tc_flower_fltr_list))
2094 			return 0;
2095 
2096 		NL_SET_ERR_MSG_MOD(cls_flower->common.extack, "failed to delete TC flower filter because unable to find it");
2097 		return -EINVAL;
2098 	}
2099 
2100 	fltr->extack = cls_flower->common.extack;
2101 	/* delete filter from HW */
2102 	err = ice_del_tc_fltr(vsi, fltr);
2103 	if (err)
2104 		return err;
2105 
2106 	/* delete filter from an ordered list */
2107 	hlist_del(&fltr->tc_flower_node);
2108 
2109 	/* free the filter node */
2110 	kfree(fltr);
2111 
2112 	return 0;
2113 }
2114 
2115 /**
2116  * ice_replay_tc_fltrs - replay TC filters
2117  * @pf: pointer to PF struct
2118  */
2119 void ice_replay_tc_fltrs(struct ice_pf *pf)
2120 {
2121 	struct ice_tc_flower_fltr *fltr;
2122 	struct hlist_node *node;
2123 
2124 	hlist_for_each_entry_safe(fltr, node,
2125 				  &pf->tc_flower_fltr_list,
2126 				  tc_flower_node) {
2127 		fltr->extack = NULL;
2128 		ice_add_switch_fltr(fltr->src_vsi, fltr);
2129 	}
2130 }
2131