1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2018-2020, Intel Corporation. */
3 
4 /* flow director ethtool support for ice */
5 
6 #include "ice.h"
7 #include "ice_lib.h"
8 #include "ice_fdir.h"
9 #include "ice_flow.h"
10 
11 static struct in6_addr full_ipv6_addr_mask = {
12 	.in6_u = {
13 		.u6_addr8 = {
14 			0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
15 			0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
16 		}
17 	}
18 };
19 
20 static struct in6_addr zero_ipv6_addr_mask = {
21 	.in6_u = {
22 		.u6_addr8 = {
23 			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
24 			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
25 		}
26 	}
27 };
28 
29 /* calls to ice_flow_add_prof require the number of segments in the array
30  * for segs_cnt. In this code that is one more than the index.
31  */
32 #define TNL_SEG_CNT(_TNL_) ((_TNL_) + 1)
33 
34 /**
35  * ice_fltr_to_ethtool_flow - convert filter type values to ethtool
36  * flow type values
37  * @flow: filter type to be converted
38  *
39  * Returns the corresponding ethtool flow type.
40  */
ice_fltr_to_ethtool_flow(enum ice_fltr_ptype flow)41 static int ice_fltr_to_ethtool_flow(enum ice_fltr_ptype flow)
42 {
43 	switch (flow) {
44 	case ICE_FLTR_PTYPE_NONF_IPV4_TCP:
45 		return TCP_V4_FLOW;
46 	case ICE_FLTR_PTYPE_NONF_IPV4_UDP:
47 		return UDP_V4_FLOW;
48 	case ICE_FLTR_PTYPE_NONF_IPV4_SCTP:
49 		return SCTP_V4_FLOW;
50 	case ICE_FLTR_PTYPE_NONF_IPV4_OTHER:
51 		return IPV4_USER_FLOW;
52 	case ICE_FLTR_PTYPE_NONF_IPV6_TCP:
53 		return TCP_V6_FLOW;
54 	case ICE_FLTR_PTYPE_NONF_IPV6_UDP:
55 		return UDP_V6_FLOW;
56 	case ICE_FLTR_PTYPE_NONF_IPV6_SCTP:
57 		return SCTP_V6_FLOW;
58 	case ICE_FLTR_PTYPE_NONF_IPV6_OTHER:
59 		return IPV6_USER_FLOW;
60 	default:
61 		/* 0 is undefined ethtool flow */
62 		return 0;
63 	}
64 }
65 
66 /**
67  * ice_ethtool_flow_to_fltr - convert ethtool flow type to filter enum
68  * @eth: Ethtool flow type to be converted
69  *
70  * Returns flow enum
71  */
ice_ethtool_flow_to_fltr(int eth)72 static enum ice_fltr_ptype ice_ethtool_flow_to_fltr(int eth)
73 {
74 	switch (eth) {
75 	case TCP_V4_FLOW:
76 		return ICE_FLTR_PTYPE_NONF_IPV4_TCP;
77 	case UDP_V4_FLOW:
78 		return ICE_FLTR_PTYPE_NONF_IPV4_UDP;
79 	case SCTP_V4_FLOW:
80 		return ICE_FLTR_PTYPE_NONF_IPV4_SCTP;
81 	case IPV4_USER_FLOW:
82 		return ICE_FLTR_PTYPE_NONF_IPV4_OTHER;
83 	case TCP_V6_FLOW:
84 		return ICE_FLTR_PTYPE_NONF_IPV6_TCP;
85 	case UDP_V6_FLOW:
86 		return ICE_FLTR_PTYPE_NONF_IPV6_UDP;
87 	case SCTP_V6_FLOW:
88 		return ICE_FLTR_PTYPE_NONF_IPV6_SCTP;
89 	case IPV6_USER_FLOW:
90 		return ICE_FLTR_PTYPE_NONF_IPV6_OTHER;
91 	default:
92 		return ICE_FLTR_PTYPE_NONF_NONE;
93 	}
94 }
95 
96 /**
97  * ice_is_mask_valid - check mask field set
98  * @mask: full mask to check
99  * @field: field for which mask should be valid
100  *
101  * If the mask is fully set return true. If it is not valid for field return
102  * false.
103  */
ice_is_mask_valid(u64 mask,u64 field)104 static bool ice_is_mask_valid(u64 mask, u64 field)
105 {
106 	return (mask & field) == field;
107 }
108 
109 /**
110  * ice_get_ethtool_fdir_entry - fill ethtool structure with fdir filter data
111  * @hw: hardware structure that contains filter list
112  * @cmd: ethtool command data structure to receive the filter data
113  *
114  * Returns 0 on success and -EINVAL on failure
115  */
ice_get_ethtool_fdir_entry(struct ice_hw * hw,struct ethtool_rxnfc * cmd)116 int ice_get_ethtool_fdir_entry(struct ice_hw *hw, struct ethtool_rxnfc *cmd)
117 {
118 	struct ethtool_rx_flow_spec *fsp;
119 	struct ice_fdir_fltr *rule;
120 	int ret = 0;
121 	u16 idx;
122 
123 	fsp = (struct ethtool_rx_flow_spec *)&cmd->fs;
124 
125 	mutex_lock(&hw->fdir_fltr_lock);
126 
127 	rule = ice_fdir_find_fltr_by_idx(hw, fsp->location);
128 
129 	if (!rule || fsp->location != rule->fltr_id) {
130 		ret = -EINVAL;
131 		goto release_lock;
132 	}
133 
134 	fsp->flow_type = ice_fltr_to_ethtool_flow(rule->flow_type);
135 
136 	memset(&fsp->m_u, 0, sizeof(fsp->m_u));
137 	memset(&fsp->m_ext, 0, sizeof(fsp->m_ext));
138 
139 	switch (fsp->flow_type) {
140 	case IPV4_USER_FLOW:
141 		fsp->h_u.usr_ip4_spec.ip_ver = ETH_RX_NFC_IP4;
142 		fsp->h_u.usr_ip4_spec.proto = 0;
143 		fsp->h_u.usr_ip4_spec.l4_4_bytes = rule->ip.v4.l4_header;
144 		fsp->h_u.usr_ip4_spec.tos = rule->ip.v4.tos;
145 		fsp->h_u.usr_ip4_spec.ip4src = rule->ip.v4.src_ip;
146 		fsp->h_u.usr_ip4_spec.ip4dst = rule->ip.v4.dst_ip;
147 		fsp->m_u.usr_ip4_spec.ip4src = rule->mask.v4.src_ip;
148 		fsp->m_u.usr_ip4_spec.ip4dst = rule->mask.v4.dst_ip;
149 		fsp->m_u.usr_ip4_spec.ip_ver = 0xFF;
150 		fsp->m_u.usr_ip4_spec.proto = 0;
151 		fsp->m_u.usr_ip4_spec.l4_4_bytes = rule->mask.v4.l4_header;
152 		fsp->m_u.usr_ip4_spec.tos = rule->mask.v4.tos;
153 		break;
154 	case TCP_V4_FLOW:
155 	case UDP_V4_FLOW:
156 	case SCTP_V4_FLOW:
157 		fsp->h_u.tcp_ip4_spec.psrc = rule->ip.v4.src_port;
158 		fsp->h_u.tcp_ip4_spec.pdst = rule->ip.v4.dst_port;
159 		fsp->h_u.tcp_ip4_spec.ip4src = rule->ip.v4.src_ip;
160 		fsp->h_u.tcp_ip4_spec.ip4dst = rule->ip.v4.dst_ip;
161 		fsp->m_u.tcp_ip4_spec.psrc = rule->mask.v4.src_port;
162 		fsp->m_u.tcp_ip4_spec.pdst = rule->mask.v4.dst_port;
163 		fsp->m_u.tcp_ip4_spec.ip4src = rule->mask.v4.src_ip;
164 		fsp->m_u.tcp_ip4_spec.ip4dst = rule->mask.v4.dst_ip;
165 		break;
166 	case IPV6_USER_FLOW:
167 		fsp->h_u.usr_ip6_spec.l4_4_bytes = rule->ip.v6.l4_header;
168 		fsp->h_u.usr_ip6_spec.tclass = rule->ip.v6.tc;
169 		fsp->h_u.usr_ip6_spec.l4_proto = rule->ip.v6.proto;
170 		memcpy(fsp->h_u.tcp_ip6_spec.ip6src, rule->ip.v6.src_ip,
171 		       sizeof(struct in6_addr));
172 		memcpy(fsp->h_u.tcp_ip6_spec.ip6dst, rule->ip.v6.dst_ip,
173 		       sizeof(struct in6_addr));
174 		memcpy(fsp->m_u.tcp_ip6_spec.ip6src, rule->mask.v6.src_ip,
175 		       sizeof(struct in6_addr));
176 		memcpy(fsp->m_u.tcp_ip6_spec.ip6dst, rule->mask.v6.dst_ip,
177 		       sizeof(struct in6_addr));
178 		fsp->m_u.usr_ip6_spec.l4_4_bytes = rule->mask.v6.l4_header;
179 		fsp->m_u.usr_ip6_spec.tclass = rule->mask.v6.tc;
180 		fsp->m_u.usr_ip6_spec.l4_proto = rule->mask.v6.proto;
181 		break;
182 	case TCP_V6_FLOW:
183 	case UDP_V6_FLOW:
184 	case SCTP_V6_FLOW:
185 		memcpy(fsp->h_u.tcp_ip6_spec.ip6src, rule->ip.v6.src_ip,
186 		       sizeof(struct in6_addr));
187 		memcpy(fsp->h_u.tcp_ip6_spec.ip6dst, rule->ip.v6.dst_ip,
188 		       sizeof(struct in6_addr));
189 		fsp->h_u.tcp_ip6_spec.psrc = rule->ip.v6.src_port;
190 		fsp->h_u.tcp_ip6_spec.pdst = rule->ip.v6.dst_port;
191 		memcpy(fsp->m_u.tcp_ip6_spec.ip6src,
192 		       rule->mask.v6.src_ip,
193 		       sizeof(struct in6_addr));
194 		memcpy(fsp->m_u.tcp_ip6_spec.ip6dst,
195 		       rule->mask.v6.dst_ip,
196 		       sizeof(struct in6_addr));
197 		fsp->m_u.tcp_ip6_spec.psrc = rule->mask.v6.src_port;
198 		fsp->m_u.tcp_ip6_spec.pdst = rule->mask.v6.dst_port;
199 		fsp->h_u.tcp_ip6_spec.tclass = rule->ip.v6.tc;
200 		fsp->m_u.tcp_ip6_spec.tclass = rule->mask.v6.tc;
201 		break;
202 	default:
203 		break;
204 	}
205 
206 	if (rule->dest_ctl == ICE_FLTR_PRGM_DESC_DEST_DROP_PKT)
207 		fsp->ring_cookie = RX_CLS_FLOW_DISC;
208 	else
209 		fsp->ring_cookie = rule->orig_q_index;
210 
211 	idx = ice_ethtool_flow_to_fltr(fsp->flow_type);
212 	if (idx == ICE_FLTR_PTYPE_NONF_NONE) {
213 		dev_err(ice_hw_to_dev(hw), "Missing input index for flow_type %d\n",
214 			rule->flow_type);
215 		ret = -EINVAL;
216 	}
217 
218 release_lock:
219 	mutex_unlock(&hw->fdir_fltr_lock);
220 	return ret;
221 }
222 
223 /**
224  * ice_get_fdir_fltr_ids - fill buffer with filter IDs of active filters
225  * @hw: hardware structure containing the filter list
226  * @cmd: ethtool command data structure
227  * @rule_locs: ethtool array passed in from OS to receive filter IDs
228  *
229  * Returns 0 as expected for success by ethtool
230  */
231 int
ice_get_fdir_fltr_ids(struct ice_hw * hw,struct ethtool_rxnfc * cmd,u32 * rule_locs)232 ice_get_fdir_fltr_ids(struct ice_hw *hw, struct ethtool_rxnfc *cmd,
233 		      u32 *rule_locs)
234 {
235 	struct ice_fdir_fltr *f_rule;
236 	unsigned int cnt = 0;
237 	int val = 0;
238 
239 	/* report total rule count */
240 	cmd->data = ice_get_fdir_cnt_all(hw);
241 
242 	mutex_lock(&hw->fdir_fltr_lock);
243 
244 	list_for_each_entry(f_rule, &hw->fdir_list_head, fltr_node) {
245 		if (cnt == cmd->rule_cnt) {
246 			val = -EMSGSIZE;
247 			goto release_lock;
248 		}
249 		rule_locs[cnt] = f_rule->fltr_id;
250 		cnt++;
251 	}
252 
253 release_lock:
254 	mutex_unlock(&hw->fdir_fltr_lock);
255 	if (!val)
256 		cmd->rule_cnt = cnt;
257 	return val;
258 }
259 
260 /**
261  * ice_fdir_remap_entries - update the FDir entries in profile
262  * @prof: FDir structure pointer
263  * @tun: tunneled or non-tunneled packet
264  * @idx: FDir entry index
265  */
266 static void
ice_fdir_remap_entries(struct ice_fd_hw_prof * prof,int tun,int idx)267 ice_fdir_remap_entries(struct ice_fd_hw_prof *prof, int tun, int idx)
268 {
269 	if (idx != prof->cnt && tun < ICE_FD_HW_SEG_MAX) {
270 		int i;
271 
272 		for (i = idx; i < (prof->cnt - 1); i++) {
273 			u64 old_entry_h;
274 
275 			old_entry_h = prof->entry_h[i + 1][tun];
276 			prof->entry_h[i][tun] = old_entry_h;
277 			prof->vsi_h[i] = prof->vsi_h[i + 1];
278 		}
279 
280 		prof->entry_h[i][tun] = 0;
281 		prof->vsi_h[i] = 0;
282 	}
283 }
284 
285 /**
286  * ice_fdir_rem_adq_chnl - remove an ADQ channel from HW filter rules
287  * @hw: hardware structure containing filter list
288  * @vsi_idx: VSI handle
289  */
ice_fdir_rem_adq_chnl(struct ice_hw * hw,u16 vsi_idx)290 void ice_fdir_rem_adq_chnl(struct ice_hw *hw, u16 vsi_idx)
291 {
292 	int status, flow;
293 
294 	if (!hw->fdir_prof)
295 		return;
296 
297 	for (flow = 0; flow < ICE_FLTR_PTYPE_MAX; flow++) {
298 		struct ice_fd_hw_prof *prof = hw->fdir_prof[flow];
299 		int tun, i;
300 
301 		if (!prof || !prof->cnt)
302 			continue;
303 
304 		for (tun = 0; tun < ICE_FD_HW_SEG_MAX; tun++) {
305 			u64 prof_id;
306 
307 			prof_id = flow + tun * ICE_FLTR_PTYPE_MAX;
308 
309 			for (i = 0; i < prof->cnt; i++) {
310 				if (prof->vsi_h[i] != vsi_idx)
311 					continue;
312 
313 				prof->entry_h[i][tun] = 0;
314 				prof->vsi_h[i] = 0;
315 				break;
316 			}
317 
318 			/* after clearing FDir entries update the remaining */
319 			ice_fdir_remap_entries(prof, tun, i);
320 
321 			/* find flow profile corresponding to prof_id and clear
322 			 * vsi_idx from bitmap.
323 			 */
324 			status = ice_flow_rem_vsi_prof(hw, vsi_idx, prof_id);
325 			if (status) {
326 				dev_err(ice_hw_to_dev(hw), "ice_flow_rem_vsi_prof() failed status=%d\n",
327 					status);
328 			}
329 		}
330 		prof->cnt--;
331 	}
332 }
333 
334 /**
335  * ice_fdir_get_hw_prof - return the ice_fd_hw_proc associated with a flow
336  * @hw: hardware structure containing the filter list
337  * @blk: hardware block
338  * @flow: FDir flow type to release
339  */
340 static struct ice_fd_hw_prof *
ice_fdir_get_hw_prof(struct ice_hw * hw,enum ice_block blk,int flow)341 ice_fdir_get_hw_prof(struct ice_hw *hw, enum ice_block blk, int flow)
342 {
343 	if (blk == ICE_BLK_FD && hw->fdir_prof)
344 		return hw->fdir_prof[flow];
345 
346 	return NULL;
347 }
348 
349 /**
350  * ice_fdir_erase_flow_from_hw - remove a flow from the HW profile tables
351  * @hw: hardware structure containing the filter list
352  * @blk: hardware block
353  * @flow: FDir flow type to release
354  */
355 static void
ice_fdir_erase_flow_from_hw(struct ice_hw * hw,enum ice_block blk,int flow)356 ice_fdir_erase_flow_from_hw(struct ice_hw *hw, enum ice_block blk, int flow)
357 {
358 	struct ice_fd_hw_prof *prof = ice_fdir_get_hw_prof(hw, blk, flow);
359 	int tun;
360 
361 	if (!prof)
362 		return;
363 
364 	for (tun = 0; tun < ICE_FD_HW_SEG_MAX; tun++) {
365 		u64 prof_id;
366 		int j;
367 
368 		prof_id = flow + tun * ICE_FLTR_PTYPE_MAX;
369 		for (j = 0; j < prof->cnt; j++) {
370 			u16 vsi_num;
371 
372 			if (!prof->entry_h[j][tun] || !prof->vsi_h[j])
373 				continue;
374 			vsi_num = ice_get_hw_vsi_num(hw, prof->vsi_h[j]);
375 			ice_rem_prof_id_flow(hw, blk, vsi_num, prof_id);
376 			ice_flow_rem_entry(hw, blk, prof->entry_h[j][tun]);
377 			prof->entry_h[j][tun] = 0;
378 		}
379 		ice_flow_rem_prof(hw, blk, prof_id);
380 	}
381 }
382 
383 /**
384  * ice_fdir_rem_flow - release the ice_flow structures for a filter type
385  * @hw: hardware structure containing the filter list
386  * @blk: hardware block
387  * @flow_type: FDir flow type to release
388  */
389 static void
ice_fdir_rem_flow(struct ice_hw * hw,enum ice_block blk,enum ice_fltr_ptype flow_type)390 ice_fdir_rem_flow(struct ice_hw *hw, enum ice_block blk,
391 		  enum ice_fltr_ptype flow_type)
392 {
393 	int flow = (int)flow_type & ~FLOW_EXT;
394 	struct ice_fd_hw_prof *prof;
395 	int tun, i;
396 
397 	prof = ice_fdir_get_hw_prof(hw, blk, flow);
398 	if (!prof)
399 		return;
400 
401 	ice_fdir_erase_flow_from_hw(hw, blk, flow);
402 	for (i = 0; i < prof->cnt; i++)
403 		prof->vsi_h[i] = 0;
404 	for (tun = 0; tun < ICE_FD_HW_SEG_MAX; tun++) {
405 		if (!prof->fdir_seg[tun])
406 			continue;
407 		devm_kfree(ice_hw_to_dev(hw), prof->fdir_seg[tun]);
408 		prof->fdir_seg[tun] = NULL;
409 	}
410 	prof->cnt = 0;
411 }
412 
413 /**
414  * ice_fdir_release_flows - release all flows in use for later replay
415  * @hw: pointer to HW instance
416  */
ice_fdir_release_flows(struct ice_hw * hw)417 void ice_fdir_release_flows(struct ice_hw *hw)
418 {
419 	int flow;
420 
421 	/* release Flow Director HW table entries */
422 	for (flow = 0; flow < ICE_FLTR_PTYPE_MAX; flow++)
423 		ice_fdir_erase_flow_from_hw(hw, ICE_BLK_FD, flow);
424 }
425 
426 /**
427  * ice_fdir_replay_flows - replay HW Flow Director filter info
428  * @hw: pointer to HW instance
429  */
ice_fdir_replay_flows(struct ice_hw * hw)430 void ice_fdir_replay_flows(struct ice_hw *hw)
431 {
432 	int flow;
433 
434 	for (flow = 0; flow < ICE_FLTR_PTYPE_MAX; flow++) {
435 		int tun;
436 
437 		if (!hw->fdir_prof[flow] || !hw->fdir_prof[flow]->cnt)
438 			continue;
439 		for (tun = 0; tun < ICE_FD_HW_SEG_MAX; tun++) {
440 			struct ice_flow_prof *hw_prof;
441 			struct ice_fd_hw_prof *prof;
442 			u64 prof_id;
443 			int j;
444 
445 			prof = hw->fdir_prof[flow];
446 			prof_id = flow + tun * ICE_FLTR_PTYPE_MAX;
447 			ice_flow_add_prof(hw, ICE_BLK_FD, ICE_FLOW_RX, prof_id,
448 					  prof->fdir_seg[tun], TNL_SEG_CNT(tun),
449 					  &hw_prof);
450 			for (j = 0; j < prof->cnt; j++) {
451 				enum ice_flow_priority prio;
452 				u64 entry_h = 0;
453 				int err;
454 
455 				prio = ICE_FLOW_PRIO_NORMAL;
456 				err = ice_flow_add_entry(hw, ICE_BLK_FD,
457 							 prof_id,
458 							 prof->vsi_h[0],
459 							 prof->vsi_h[j],
460 							 prio, prof->fdir_seg,
461 							 &entry_h);
462 				if (err) {
463 					dev_err(ice_hw_to_dev(hw), "Could not replay Flow Director, flow type %d\n",
464 						flow);
465 					continue;
466 				}
467 				prof->entry_h[j][tun] = entry_h;
468 			}
469 		}
470 	}
471 }
472 
473 /**
474  * ice_parse_rx_flow_user_data - deconstruct user-defined data
475  * @fsp: pointer to ethtool Rx flow specification
476  * @data: pointer to userdef data structure for storage
477  *
478  * Returns 0 on success, negative error value on failure
479  */
480 static int
ice_parse_rx_flow_user_data(struct ethtool_rx_flow_spec * fsp,struct ice_rx_flow_userdef * data)481 ice_parse_rx_flow_user_data(struct ethtool_rx_flow_spec *fsp,
482 			    struct ice_rx_flow_userdef *data)
483 {
484 	u64 value, mask;
485 
486 	memset(data, 0, sizeof(*data));
487 	if (!(fsp->flow_type & FLOW_EXT))
488 		return 0;
489 
490 	value = be64_to_cpu(*((__force __be64 *)fsp->h_ext.data));
491 	mask = be64_to_cpu(*((__force __be64 *)fsp->m_ext.data));
492 	if (!mask)
493 		return 0;
494 
495 #define ICE_USERDEF_FLEX_WORD_M	GENMASK_ULL(15, 0)
496 #define ICE_USERDEF_FLEX_OFFS_S	16
497 #define ICE_USERDEF_FLEX_OFFS_M	GENMASK_ULL(31, ICE_USERDEF_FLEX_OFFS_S)
498 #define ICE_USERDEF_FLEX_FLTR_M	GENMASK_ULL(31, 0)
499 
500 	/* 0x1fe is the maximum value for offsets stored in the internal
501 	 * filtering tables.
502 	 */
503 #define ICE_USERDEF_FLEX_MAX_OFFS_VAL 0x1fe
504 
505 	if (!ice_is_mask_valid(mask, ICE_USERDEF_FLEX_FLTR_M) ||
506 	    value > ICE_USERDEF_FLEX_FLTR_M)
507 		return -EINVAL;
508 
509 	data->flex_word = value & ICE_USERDEF_FLEX_WORD_M;
510 	data->flex_offset = (value & ICE_USERDEF_FLEX_OFFS_M) >>
511 			     ICE_USERDEF_FLEX_OFFS_S;
512 	if (data->flex_offset > ICE_USERDEF_FLEX_MAX_OFFS_VAL)
513 		return -EINVAL;
514 
515 	data->flex_fltr = true;
516 
517 	return 0;
518 }
519 
520 /**
521  * ice_fdir_num_avail_fltr - return the number of unused flow director filters
522  * @hw: pointer to hardware structure
523  * @vsi: software VSI structure
524  *
525  * There are 2 filter pools: guaranteed and best effort(shared). Each VSI can
526  * use filters from either pool. The guaranteed pool is divided between VSIs.
527  * The best effort filter pool is common to all VSIs and is a device shared
528  * resource pool. The number of filters available to this VSI is the sum of
529  * the VSIs guaranteed filter pool and the global available best effort
530  * filter pool.
531  *
532  * Returns the number of available flow director filters to this VSI
533  */
ice_fdir_num_avail_fltr(struct ice_hw * hw,struct ice_vsi * vsi)534 static int ice_fdir_num_avail_fltr(struct ice_hw *hw, struct ice_vsi *vsi)
535 {
536 	u16 vsi_num = ice_get_hw_vsi_num(hw, vsi->idx);
537 	u16 num_guar;
538 	u16 num_be;
539 
540 	/* total guaranteed filters assigned to this VSI */
541 	num_guar = vsi->num_gfltr;
542 
543 	/* minus the guaranteed filters programed by this VSI */
544 	num_guar -= (rd32(hw, VSIQF_FD_CNT(vsi_num)) &
545 		     VSIQF_FD_CNT_FD_GCNT_M) >> VSIQF_FD_CNT_FD_GCNT_S;
546 
547 	/* total global best effort filters */
548 	num_be = hw->func_caps.fd_fltr_best_effort;
549 
550 	/* minus the global best effort filters programmed */
551 	num_be -= (rd32(hw, GLQF_FD_CNT) & GLQF_FD_CNT_FD_BCNT_M) >>
552 		   GLQF_FD_CNT_FD_BCNT_S;
553 
554 	return num_guar + num_be;
555 }
556 
557 /**
558  * ice_fdir_alloc_flow_prof - allocate FDir flow profile structure(s)
559  * @hw: HW structure containing the FDir flow profile structure(s)
560  * @flow: flow type to allocate the flow profile for
561  *
562  * Allocate the fdir_prof and fdir_prof[flow] if not already created. Return 0
563  * on success and negative on error.
564  */
565 static int
ice_fdir_alloc_flow_prof(struct ice_hw * hw,enum ice_fltr_ptype flow)566 ice_fdir_alloc_flow_prof(struct ice_hw *hw, enum ice_fltr_ptype flow)
567 {
568 	if (!hw)
569 		return -EINVAL;
570 
571 	if (!hw->fdir_prof) {
572 		hw->fdir_prof = devm_kcalloc(ice_hw_to_dev(hw),
573 					     ICE_FLTR_PTYPE_MAX,
574 					     sizeof(*hw->fdir_prof),
575 					     GFP_KERNEL);
576 		if (!hw->fdir_prof)
577 			return -ENOMEM;
578 	}
579 
580 	if (!hw->fdir_prof[flow]) {
581 		hw->fdir_prof[flow] = devm_kzalloc(ice_hw_to_dev(hw),
582 						   sizeof(**hw->fdir_prof),
583 						   GFP_KERNEL);
584 		if (!hw->fdir_prof[flow])
585 			return -ENOMEM;
586 	}
587 
588 	return 0;
589 }
590 
591 /**
592  * ice_fdir_prof_vsi_idx - find or insert a vsi_idx in structure
593  * @prof: pointer to flow director HW profile
594  * @vsi_idx: vsi_idx to locate
595  *
596  * return the index of the vsi_idx. if vsi_idx is not found insert it
597  * into the vsi_h table.
598  */
599 static u16
ice_fdir_prof_vsi_idx(struct ice_fd_hw_prof * prof,int vsi_idx)600 ice_fdir_prof_vsi_idx(struct ice_fd_hw_prof *prof, int vsi_idx)
601 {
602 	u16 idx = 0;
603 
604 	for (idx = 0; idx < prof->cnt; idx++)
605 		if (prof->vsi_h[idx] == vsi_idx)
606 			return idx;
607 
608 	if (idx == prof->cnt)
609 		prof->vsi_h[prof->cnt++] = vsi_idx;
610 	return idx;
611 }
612 
613 /**
614  * ice_fdir_set_hw_fltr_rule - Configure HW tables to generate a FDir rule
615  * @pf: pointer to the PF structure
616  * @seg: protocol header description pointer
617  * @flow: filter enum
618  * @tun: FDir segment to program
619  */
620 static int
ice_fdir_set_hw_fltr_rule(struct ice_pf * pf,struct ice_flow_seg_info * seg,enum ice_fltr_ptype flow,enum ice_fd_hw_seg tun)621 ice_fdir_set_hw_fltr_rule(struct ice_pf *pf, struct ice_flow_seg_info *seg,
622 			  enum ice_fltr_ptype flow, enum ice_fd_hw_seg tun)
623 {
624 	struct device *dev = ice_pf_to_dev(pf);
625 	struct ice_vsi *main_vsi, *ctrl_vsi;
626 	struct ice_flow_seg_info *old_seg;
627 	struct ice_flow_prof *prof = NULL;
628 	struct ice_fd_hw_prof *hw_prof;
629 	struct ice_hw *hw = &pf->hw;
630 	u64 entry1_h = 0;
631 	u64 entry2_h = 0;
632 	bool del_last;
633 	u64 prof_id;
634 	int err;
635 	int idx;
636 
637 	main_vsi = ice_get_main_vsi(pf);
638 	if (!main_vsi)
639 		return -EINVAL;
640 
641 	ctrl_vsi = ice_get_ctrl_vsi(pf);
642 	if (!ctrl_vsi)
643 		return -EINVAL;
644 
645 	err = ice_fdir_alloc_flow_prof(hw, flow);
646 	if (err)
647 		return err;
648 
649 	hw_prof = hw->fdir_prof[flow];
650 	old_seg = hw_prof->fdir_seg[tun];
651 	if (old_seg) {
652 		/* This flow_type already has a changed input set.
653 		 * If it matches the requested input set then we are
654 		 * done. Or, if it's different then it's an error.
655 		 */
656 		if (!memcmp(old_seg, seg, sizeof(*seg)))
657 			return -EEXIST;
658 
659 		/* if there are FDir filters using this flow,
660 		 * then return error.
661 		 */
662 		if (hw->fdir_fltr_cnt[flow]) {
663 			dev_err(dev, "Failed to add filter.  Flow director filters on each port must have the same input set.\n");
664 			return -EINVAL;
665 		}
666 
667 		if (ice_is_arfs_using_perfect_flow(hw, flow)) {
668 			dev_err(dev, "aRFS using perfect flow type %d, cannot change input set\n",
669 				flow);
670 			return -EINVAL;
671 		}
672 
673 		/* remove HW filter definition */
674 		ice_fdir_rem_flow(hw, ICE_BLK_FD, flow);
675 	}
676 
677 	/* Adding a profile, but there is only one header supported.
678 	 * That is the final parameters are 1 header (segment), no
679 	 * actions (NULL) and zero actions 0.
680 	 */
681 	prof_id = flow + tun * ICE_FLTR_PTYPE_MAX;
682 	err = ice_flow_add_prof(hw, ICE_BLK_FD, ICE_FLOW_RX, prof_id, seg,
683 				TNL_SEG_CNT(tun), &prof);
684 	if (err)
685 		return err;
686 	err = ice_flow_add_entry(hw, ICE_BLK_FD, prof_id, main_vsi->idx,
687 				 main_vsi->idx, ICE_FLOW_PRIO_NORMAL,
688 				 seg, &entry1_h);
689 	if (err)
690 		goto err_prof;
691 	err = ice_flow_add_entry(hw, ICE_BLK_FD, prof_id, main_vsi->idx,
692 				 ctrl_vsi->idx, ICE_FLOW_PRIO_NORMAL,
693 				 seg, &entry2_h);
694 	if (err)
695 		goto err_entry;
696 
697 	hw_prof->fdir_seg[tun] = seg;
698 	hw_prof->entry_h[0][tun] = entry1_h;
699 	hw_prof->entry_h[1][tun] = entry2_h;
700 	hw_prof->vsi_h[0] = main_vsi->idx;
701 	hw_prof->vsi_h[1] = ctrl_vsi->idx;
702 	if (!hw_prof->cnt)
703 		hw_prof->cnt = 2;
704 
705 	for (idx = 1; idx < ICE_CHNL_MAX_TC; idx++) {
706 		u16 vsi_idx;
707 		u16 vsi_h;
708 
709 		if (!ice_is_adq_active(pf) || !main_vsi->tc_map_vsi[idx])
710 			continue;
711 
712 		entry1_h = 0;
713 		vsi_h = main_vsi->tc_map_vsi[idx]->idx;
714 		err = ice_flow_add_entry(hw, ICE_BLK_FD, prof_id,
715 					 main_vsi->idx, vsi_h,
716 					 ICE_FLOW_PRIO_NORMAL, seg,
717 					 &entry1_h);
718 		if (err) {
719 			dev_err(dev, "Could not add Channel VSI %d to flow group\n",
720 				idx);
721 			goto err_unroll;
722 		}
723 
724 		vsi_idx = ice_fdir_prof_vsi_idx(hw_prof,
725 						main_vsi->tc_map_vsi[idx]->idx);
726 		hw_prof->entry_h[vsi_idx][tun] = entry1_h;
727 	}
728 
729 	return 0;
730 
731 err_unroll:
732 	entry1_h = 0;
733 	hw_prof->fdir_seg[tun] = NULL;
734 
735 	/* The variable del_last will be used to determine when to clean up
736 	 * the VSI group data. The VSI data is not needed if there are no
737 	 * segments.
738 	 */
739 	del_last = true;
740 	for (idx = 0; idx < ICE_FD_HW_SEG_MAX; idx++)
741 		if (hw_prof->fdir_seg[idx]) {
742 			del_last = false;
743 			break;
744 		}
745 
746 	for (idx = 0; idx < hw_prof->cnt; idx++) {
747 		u16 vsi_num = ice_get_hw_vsi_num(hw, hw_prof->vsi_h[idx]);
748 
749 		if (!hw_prof->entry_h[idx][tun])
750 			continue;
751 		ice_rem_prof_id_flow(hw, ICE_BLK_FD, vsi_num, prof_id);
752 		ice_flow_rem_entry(hw, ICE_BLK_FD, hw_prof->entry_h[idx][tun]);
753 		hw_prof->entry_h[idx][tun] = 0;
754 		if (del_last)
755 			hw_prof->vsi_h[idx] = 0;
756 	}
757 	if (del_last)
758 		hw_prof->cnt = 0;
759 err_entry:
760 	ice_rem_prof_id_flow(hw, ICE_BLK_FD,
761 			     ice_get_hw_vsi_num(hw, main_vsi->idx), prof_id);
762 	ice_flow_rem_entry(hw, ICE_BLK_FD, entry1_h);
763 err_prof:
764 	ice_flow_rem_prof(hw, ICE_BLK_FD, prof_id);
765 	dev_err(dev, "Failed to add filter.  Flow director filters on each port must have the same input set.\n");
766 
767 	return err;
768 }
769 
770 /**
771  * ice_set_init_fdir_seg
772  * @seg: flow segment for programming
773  * @l3_proto: ICE_FLOW_SEG_HDR_IPV4 or ICE_FLOW_SEG_HDR_IPV6
774  * @l4_proto: ICE_FLOW_SEG_HDR_TCP or ICE_FLOW_SEG_HDR_UDP
775  *
776  * Set the configuration for perfect filters to the provided flow segment for
777  * programming the HW filter. This is to be called only when initializing
778  * filters as this function it assumes no filters exist.
779  */
780 static int
ice_set_init_fdir_seg(struct ice_flow_seg_info * seg,enum ice_flow_seg_hdr l3_proto,enum ice_flow_seg_hdr l4_proto)781 ice_set_init_fdir_seg(struct ice_flow_seg_info *seg,
782 		      enum ice_flow_seg_hdr l3_proto,
783 		      enum ice_flow_seg_hdr l4_proto)
784 {
785 	enum ice_flow_field src_addr, dst_addr, src_port, dst_port;
786 
787 	if (!seg)
788 		return -EINVAL;
789 
790 	if (l3_proto == ICE_FLOW_SEG_HDR_IPV4) {
791 		src_addr = ICE_FLOW_FIELD_IDX_IPV4_SA;
792 		dst_addr = ICE_FLOW_FIELD_IDX_IPV4_DA;
793 	} else if (l3_proto == ICE_FLOW_SEG_HDR_IPV6) {
794 		src_addr = ICE_FLOW_FIELD_IDX_IPV6_SA;
795 		dst_addr = ICE_FLOW_FIELD_IDX_IPV6_DA;
796 	} else {
797 		return -EINVAL;
798 	}
799 
800 	if (l4_proto == ICE_FLOW_SEG_HDR_TCP) {
801 		src_port = ICE_FLOW_FIELD_IDX_TCP_SRC_PORT;
802 		dst_port = ICE_FLOW_FIELD_IDX_TCP_DST_PORT;
803 	} else if (l4_proto == ICE_FLOW_SEG_HDR_UDP) {
804 		src_port = ICE_FLOW_FIELD_IDX_UDP_SRC_PORT;
805 		dst_port = ICE_FLOW_FIELD_IDX_UDP_DST_PORT;
806 	} else {
807 		return -EINVAL;
808 	}
809 
810 	ICE_FLOW_SET_HDRS(seg, l3_proto | l4_proto);
811 
812 	/* IP source address */
813 	ice_flow_set_fld(seg, src_addr, ICE_FLOW_FLD_OFF_INVAL,
814 			 ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL, false);
815 
816 	/* IP destination address */
817 	ice_flow_set_fld(seg, dst_addr, ICE_FLOW_FLD_OFF_INVAL,
818 			 ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL, false);
819 
820 	/* Layer 4 source port */
821 	ice_flow_set_fld(seg, src_port, ICE_FLOW_FLD_OFF_INVAL,
822 			 ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL, false);
823 
824 	/* Layer 4 destination port */
825 	ice_flow_set_fld(seg, dst_port, ICE_FLOW_FLD_OFF_INVAL,
826 			 ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL, false);
827 
828 	return 0;
829 }
830 
831 /**
832  * ice_create_init_fdir_rule
833  * @pf: PF structure
834  * @flow: filter enum
835  *
836  * Return error value or 0 on success.
837  */
838 static int
ice_create_init_fdir_rule(struct ice_pf * pf,enum ice_fltr_ptype flow)839 ice_create_init_fdir_rule(struct ice_pf *pf, enum ice_fltr_ptype flow)
840 {
841 	struct ice_flow_seg_info *seg, *tun_seg;
842 	struct device *dev = ice_pf_to_dev(pf);
843 	struct ice_hw *hw = &pf->hw;
844 	int ret;
845 
846 	/* if there is already a filter rule for kind return -EINVAL */
847 	if (hw->fdir_prof && hw->fdir_prof[flow] &&
848 	    hw->fdir_prof[flow]->fdir_seg[0])
849 		return -EINVAL;
850 
851 	seg = devm_kzalloc(dev, sizeof(*seg), GFP_KERNEL);
852 	if (!seg)
853 		return -ENOMEM;
854 
855 	tun_seg = devm_kcalloc(dev, ICE_FD_HW_SEG_MAX, sizeof(*tun_seg),
856 			       GFP_KERNEL);
857 	if (!tun_seg) {
858 		devm_kfree(dev, seg);
859 		return -ENOMEM;
860 	}
861 
862 	if (flow == ICE_FLTR_PTYPE_NONF_IPV4_TCP)
863 		ret = ice_set_init_fdir_seg(seg, ICE_FLOW_SEG_HDR_IPV4,
864 					    ICE_FLOW_SEG_HDR_TCP);
865 	else if (flow == ICE_FLTR_PTYPE_NONF_IPV4_UDP)
866 		ret = ice_set_init_fdir_seg(seg, ICE_FLOW_SEG_HDR_IPV4,
867 					    ICE_FLOW_SEG_HDR_UDP);
868 	else if (flow == ICE_FLTR_PTYPE_NONF_IPV6_TCP)
869 		ret = ice_set_init_fdir_seg(seg, ICE_FLOW_SEG_HDR_IPV6,
870 					    ICE_FLOW_SEG_HDR_TCP);
871 	else if (flow == ICE_FLTR_PTYPE_NONF_IPV6_UDP)
872 		ret = ice_set_init_fdir_seg(seg, ICE_FLOW_SEG_HDR_IPV6,
873 					    ICE_FLOW_SEG_HDR_UDP);
874 	else
875 		ret = -EINVAL;
876 	if (ret)
877 		goto err_exit;
878 
879 	/* add filter for outer headers */
880 	ret = ice_fdir_set_hw_fltr_rule(pf, seg, flow, ICE_FD_HW_SEG_NON_TUN);
881 	if (ret)
882 		/* could not write filter, free memory */
883 		goto err_exit;
884 
885 	/* make tunneled filter HW entries if possible */
886 	memcpy(&tun_seg[1], seg, sizeof(*seg));
887 	ret = ice_fdir_set_hw_fltr_rule(pf, tun_seg, flow, ICE_FD_HW_SEG_TUN);
888 	if (ret)
889 		/* could not write tunnel filter, but outer header filter
890 		 * exists
891 		 */
892 		devm_kfree(dev, tun_seg);
893 
894 	set_bit(flow, hw->fdir_perfect_fltr);
895 	return ret;
896 err_exit:
897 	devm_kfree(dev, tun_seg);
898 	devm_kfree(dev, seg);
899 
900 	return -EOPNOTSUPP;
901 }
902 
903 /**
904  * ice_set_fdir_ip4_seg
905  * @seg: flow segment for programming
906  * @tcp_ip4_spec: mask data from ethtool
907  * @l4_proto: Layer 4 protocol to program
908  * @perfect_fltr: only valid on success; returns true if perfect filter,
909  *		  false if not
910  *
911  * Set the mask data into the flow segment to be used to program HW
912  * table based on provided L4 protocol for IPv4
913  */
914 static int
ice_set_fdir_ip4_seg(struct ice_flow_seg_info * seg,struct ethtool_tcpip4_spec * tcp_ip4_spec,enum ice_flow_seg_hdr l4_proto,bool * perfect_fltr)915 ice_set_fdir_ip4_seg(struct ice_flow_seg_info *seg,
916 		     struct ethtool_tcpip4_spec *tcp_ip4_spec,
917 		     enum ice_flow_seg_hdr l4_proto, bool *perfect_fltr)
918 {
919 	enum ice_flow_field src_port, dst_port;
920 
921 	/* make sure we don't have any empty rule */
922 	if (!tcp_ip4_spec->psrc && !tcp_ip4_spec->ip4src &&
923 	    !tcp_ip4_spec->pdst && !tcp_ip4_spec->ip4dst)
924 		return -EINVAL;
925 
926 	/* filtering on TOS not supported */
927 	if (tcp_ip4_spec->tos)
928 		return -EOPNOTSUPP;
929 
930 	if (l4_proto == ICE_FLOW_SEG_HDR_TCP) {
931 		src_port = ICE_FLOW_FIELD_IDX_TCP_SRC_PORT;
932 		dst_port = ICE_FLOW_FIELD_IDX_TCP_DST_PORT;
933 	} else if (l4_proto == ICE_FLOW_SEG_HDR_UDP) {
934 		src_port = ICE_FLOW_FIELD_IDX_UDP_SRC_PORT;
935 		dst_port = ICE_FLOW_FIELD_IDX_UDP_DST_PORT;
936 	} else if (l4_proto == ICE_FLOW_SEG_HDR_SCTP) {
937 		src_port = ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT;
938 		dst_port = ICE_FLOW_FIELD_IDX_SCTP_DST_PORT;
939 	} else {
940 		return -EOPNOTSUPP;
941 	}
942 
943 	*perfect_fltr = true;
944 	ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_IPV4 | l4_proto);
945 
946 	/* IP source address */
947 	if (tcp_ip4_spec->ip4src == htonl(0xFFFFFFFF))
948 		ice_flow_set_fld(seg, ICE_FLOW_FIELD_IDX_IPV4_SA,
949 				 ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
950 				 ICE_FLOW_FLD_OFF_INVAL, false);
951 	else if (!tcp_ip4_spec->ip4src)
952 		*perfect_fltr = false;
953 	else
954 		return -EOPNOTSUPP;
955 
956 	/* IP destination address */
957 	if (tcp_ip4_spec->ip4dst == htonl(0xFFFFFFFF))
958 		ice_flow_set_fld(seg, ICE_FLOW_FIELD_IDX_IPV4_DA,
959 				 ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
960 				 ICE_FLOW_FLD_OFF_INVAL, false);
961 	else if (!tcp_ip4_spec->ip4dst)
962 		*perfect_fltr = false;
963 	else
964 		return -EOPNOTSUPP;
965 
966 	/* Layer 4 source port */
967 	if (tcp_ip4_spec->psrc == htons(0xFFFF))
968 		ice_flow_set_fld(seg, src_port, ICE_FLOW_FLD_OFF_INVAL,
969 				 ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
970 				 false);
971 	else if (!tcp_ip4_spec->psrc)
972 		*perfect_fltr = false;
973 	else
974 		return -EOPNOTSUPP;
975 
976 	/* Layer 4 destination port */
977 	if (tcp_ip4_spec->pdst == htons(0xFFFF))
978 		ice_flow_set_fld(seg, dst_port, ICE_FLOW_FLD_OFF_INVAL,
979 				 ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
980 				 false);
981 	else if (!tcp_ip4_spec->pdst)
982 		*perfect_fltr = false;
983 	else
984 		return -EOPNOTSUPP;
985 
986 	return 0;
987 }
988 
989 /**
990  * ice_set_fdir_ip4_usr_seg
991  * @seg: flow segment for programming
992  * @usr_ip4_spec: ethtool userdef packet offset
993  * @perfect_fltr: only valid on success; returns true if perfect filter,
994  *		  false if not
995  *
996  * Set the offset data into the flow segment to be used to program HW
997  * table for IPv4
998  */
999 static int
ice_set_fdir_ip4_usr_seg(struct ice_flow_seg_info * seg,struct ethtool_usrip4_spec * usr_ip4_spec,bool * perfect_fltr)1000 ice_set_fdir_ip4_usr_seg(struct ice_flow_seg_info *seg,
1001 			 struct ethtool_usrip4_spec *usr_ip4_spec,
1002 			 bool *perfect_fltr)
1003 {
1004 	/* first 4 bytes of Layer 4 header */
1005 	if (usr_ip4_spec->l4_4_bytes)
1006 		return -EINVAL;
1007 	if (usr_ip4_spec->tos)
1008 		return -EINVAL;
1009 	if (usr_ip4_spec->ip_ver)
1010 		return -EINVAL;
1011 	/* Filtering on Layer 4 protocol not supported */
1012 	if (usr_ip4_spec->proto)
1013 		return -EOPNOTSUPP;
1014 	/* empty rules are not valid */
1015 	if (!usr_ip4_spec->ip4src && !usr_ip4_spec->ip4dst)
1016 		return -EINVAL;
1017 
1018 	*perfect_fltr = true;
1019 	ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_IPV4);
1020 
1021 	/* IP source address */
1022 	if (usr_ip4_spec->ip4src == htonl(0xFFFFFFFF))
1023 		ice_flow_set_fld(seg, ICE_FLOW_FIELD_IDX_IPV4_SA,
1024 				 ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
1025 				 ICE_FLOW_FLD_OFF_INVAL, false);
1026 	else if (!usr_ip4_spec->ip4src)
1027 		*perfect_fltr = false;
1028 	else
1029 		return -EOPNOTSUPP;
1030 
1031 	/* IP destination address */
1032 	if (usr_ip4_spec->ip4dst == htonl(0xFFFFFFFF))
1033 		ice_flow_set_fld(seg, ICE_FLOW_FIELD_IDX_IPV4_DA,
1034 				 ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
1035 				 ICE_FLOW_FLD_OFF_INVAL, false);
1036 	else if (!usr_ip4_spec->ip4dst)
1037 		*perfect_fltr = false;
1038 	else
1039 		return -EOPNOTSUPP;
1040 
1041 	return 0;
1042 }
1043 
1044 /**
1045  * ice_set_fdir_ip6_seg
1046  * @seg: flow segment for programming
1047  * @tcp_ip6_spec: mask data from ethtool
1048  * @l4_proto: Layer 4 protocol to program
1049  * @perfect_fltr: only valid on success; returns true if perfect filter,
1050  *		  false if not
1051  *
1052  * Set the mask data into the flow segment to be used to program HW
1053  * table based on provided L4 protocol for IPv6
1054  */
1055 static int
ice_set_fdir_ip6_seg(struct ice_flow_seg_info * seg,struct ethtool_tcpip6_spec * tcp_ip6_spec,enum ice_flow_seg_hdr l4_proto,bool * perfect_fltr)1056 ice_set_fdir_ip6_seg(struct ice_flow_seg_info *seg,
1057 		     struct ethtool_tcpip6_spec *tcp_ip6_spec,
1058 		     enum ice_flow_seg_hdr l4_proto, bool *perfect_fltr)
1059 {
1060 	enum ice_flow_field src_port, dst_port;
1061 
1062 	/* make sure we don't have any empty rule */
1063 	if (!memcmp(tcp_ip6_spec->ip6src, &zero_ipv6_addr_mask,
1064 		    sizeof(struct in6_addr)) &&
1065 	    !memcmp(tcp_ip6_spec->ip6dst, &zero_ipv6_addr_mask,
1066 		    sizeof(struct in6_addr)) &&
1067 	    !tcp_ip6_spec->psrc && !tcp_ip6_spec->pdst)
1068 		return -EINVAL;
1069 
1070 	/* filtering on TC not supported */
1071 	if (tcp_ip6_spec->tclass)
1072 		return -EOPNOTSUPP;
1073 
1074 	if (l4_proto == ICE_FLOW_SEG_HDR_TCP) {
1075 		src_port = ICE_FLOW_FIELD_IDX_TCP_SRC_PORT;
1076 		dst_port = ICE_FLOW_FIELD_IDX_TCP_DST_PORT;
1077 	} else if (l4_proto == ICE_FLOW_SEG_HDR_UDP) {
1078 		src_port = ICE_FLOW_FIELD_IDX_UDP_SRC_PORT;
1079 		dst_port = ICE_FLOW_FIELD_IDX_UDP_DST_PORT;
1080 	} else if (l4_proto == ICE_FLOW_SEG_HDR_SCTP) {
1081 		src_port = ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT;
1082 		dst_port = ICE_FLOW_FIELD_IDX_SCTP_DST_PORT;
1083 	} else {
1084 		return -EINVAL;
1085 	}
1086 
1087 	*perfect_fltr = true;
1088 	ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_IPV6 | l4_proto);
1089 
1090 	if (!memcmp(tcp_ip6_spec->ip6src, &full_ipv6_addr_mask,
1091 		    sizeof(struct in6_addr)))
1092 		ice_flow_set_fld(seg, ICE_FLOW_FIELD_IDX_IPV6_SA,
1093 				 ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
1094 				 ICE_FLOW_FLD_OFF_INVAL, false);
1095 	else if (!memcmp(tcp_ip6_spec->ip6src, &zero_ipv6_addr_mask,
1096 			 sizeof(struct in6_addr)))
1097 		*perfect_fltr = false;
1098 	else
1099 		return -EOPNOTSUPP;
1100 
1101 	if (!memcmp(tcp_ip6_spec->ip6dst, &full_ipv6_addr_mask,
1102 		    sizeof(struct in6_addr)))
1103 		ice_flow_set_fld(seg, ICE_FLOW_FIELD_IDX_IPV6_DA,
1104 				 ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
1105 				 ICE_FLOW_FLD_OFF_INVAL, false);
1106 	else if (!memcmp(tcp_ip6_spec->ip6dst, &zero_ipv6_addr_mask,
1107 			 sizeof(struct in6_addr)))
1108 		*perfect_fltr = false;
1109 	else
1110 		return -EOPNOTSUPP;
1111 
1112 	/* Layer 4 source port */
1113 	if (tcp_ip6_spec->psrc == htons(0xFFFF))
1114 		ice_flow_set_fld(seg, src_port, ICE_FLOW_FLD_OFF_INVAL,
1115 				 ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
1116 				 false);
1117 	else if (!tcp_ip6_spec->psrc)
1118 		*perfect_fltr = false;
1119 	else
1120 		return -EOPNOTSUPP;
1121 
1122 	/* Layer 4 destination port */
1123 	if (tcp_ip6_spec->pdst == htons(0xFFFF))
1124 		ice_flow_set_fld(seg, dst_port, ICE_FLOW_FLD_OFF_INVAL,
1125 				 ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
1126 				 false);
1127 	else if (!tcp_ip6_spec->pdst)
1128 		*perfect_fltr = false;
1129 	else
1130 		return -EOPNOTSUPP;
1131 
1132 	return 0;
1133 }
1134 
1135 /**
1136  * ice_set_fdir_ip6_usr_seg
1137  * @seg: flow segment for programming
1138  * @usr_ip6_spec: ethtool userdef packet offset
1139  * @perfect_fltr: only valid on success; returns true if perfect filter,
1140  *		  false if not
1141  *
1142  * Set the offset data into the flow segment to be used to program HW
1143  * table for IPv6
1144  */
1145 static int
ice_set_fdir_ip6_usr_seg(struct ice_flow_seg_info * seg,struct ethtool_usrip6_spec * usr_ip6_spec,bool * perfect_fltr)1146 ice_set_fdir_ip6_usr_seg(struct ice_flow_seg_info *seg,
1147 			 struct ethtool_usrip6_spec *usr_ip6_spec,
1148 			 bool *perfect_fltr)
1149 {
1150 	/* filtering on Layer 4 bytes not supported */
1151 	if (usr_ip6_spec->l4_4_bytes)
1152 		return -EOPNOTSUPP;
1153 	/* filtering on TC not supported */
1154 	if (usr_ip6_spec->tclass)
1155 		return -EOPNOTSUPP;
1156 	/* filtering on Layer 4 protocol not supported */
1157 	if (usr_ip6_spec->l4_proto)
1158 		return -EOPNOTSUPP;
1159 	/* empty rules are not valid */
1160 	if (!memcmp(usr_ip6_spec->ip6src, &zero_ipv6_addr_mask,
1161 		    sizeof(struct in6_addr)) &&
1162 	    !memcmp(usr_ip6_spec->ip6dst, &zero_ipv6_addr_mask,
1163 		    sizeof(struct in6_addr)))
1164 		return -EINVAL;
1165 
1166 	*perfect_fltr = true;
1167 	ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_IPV6);
1168 
1169 	if (!memcmp(usr_ip6_spec->ip6src, &full_ipv6_addr_mask,
1170 		    sizeof(struct in6_addr)))
1171 		ice_flow_set_fld(seg, ICE_FLOW_FIELD_IDX_IPV6_SA,
1172 				 ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
1173 				 ICE_FLOW_FLD_OFF_INVAL, false);
1174 	else if (!memcmp(usr_ip6_spec->ip6src, &zero_ipv6_addr_mask,
1175 			 sizeof(struct in6_addr)))
1176 		*perfect_fltr = false;
1177 	else
1178 		return -EOPNOTSUPP;
1179 
1180 	if (!memcmp(usr_ip6_spec->ip6dst, &full_ipv6_addr_mask,
1181 		    sizeof(struct in6_addr)))
1182 		ice_flow_set_fld(seg, ICE_FLOW_FIELD_IDX_IPV6_DA,
1183 				 ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL,
1184 				 ICE_FLOW_FLD_OFF_INVAL, false);
1185 	else if (!memcmp(usr_ip6_spec->ip6dst, &zero_ipv6_addr_mask,
1186 			 sizeof(struct in6_addr)))
1187 		*perfect_fltr = false;
1188 	else
1189 		return -EOPNOTSUPP;
1190 
1191 	return 0;
1192 }
1193 
1194 /**
1195  * ice_cfg_fdir_xtrct_seq - Configure extraction sequence for the given filter
1196  * @pf: PF structure
1197  * @fsp: pointer to ethtool Rx flow specification
1198  * @user: user defined data from flow specification
1199  *
1200  * Returns 0 on success.
1201  */
1202 static int
ice_cfg_fdir_xtrct_seq(struct ice_pf * pf,struct ethtool_rx_flow_spec * fsp,struct ice_rx_flow_userdef * user)1203 ice_cfg_fdir_xtrct_seq(struct ice_pf *pf, struct ethtool_rx_flow_spec *fsp,
1204 		       struct ice_rx_flow_userdef *user)
1205 {
1206 	struct ice_flow_seg_info *seg, *tun_seg;
1207 	struct device *dev = ice_pf_to_dev(pf);
1208 	enum ice_fltr_ptype fltr_idx;
1209 	struct ice_hw *hw = &pf->hw;
1210 	bool perfect_filter;
1211 	int ret;
1212 
1213 	seg = devm_kzalloc(dev, sizeof(*seg), GFP_KERNEL);
1214 	if (!seg)
1215 		return -ENOMEM;
1216 
1217 	tun_seg = devm_kcalloc(dev, ICE_FD_HW_SEG_MAX, sizeof(*tun_seg),
1218 			       GFP_KERNEL);
1219 	if (!tun_seg) {
1220 		devm_kfree(dev, seg);
1221 		return -ENOMEM;
1222 	}
1223 
1224 	switch (fsp->flow_type & ~FLOW_EXT) {
1225 	case TCP_V4_FLOW:
1226 		ret = ice_set_fdir_ip4_seg(seg, &fsp->m_u.tcp_ip4_spec,
1227 					   ICE_FLOW_SEG_HDR_TCP,
1228 					   &perfect_filter);
1229 		break;
1230 	case UDP_V4_FLOW:
1231 		ret = ice_set_fdir_ip4_seg(seg, &fsp->m_u.tcp_ip4_spec,
1232 					   ICE_FLOW_SEG_HDR_UDP,
1233 					   &perfect_filter);
1234 		break;
1235 	case SCTP_V4_FLOW:
1236 		ret = ice_set_fdir_ip4_seg(seg, &fsp->m_u.tcp_ip4_spec,
1237 					   ICE_FLOW_SEG_HDR_SCTP,
1238 					   &perfect_filter);
1239 		break;
1240 	case IPV4_USER_FLOW:
1241 		ret = ice_set_fdir_ip4_usr_seg(seg, &fsp->m_u.usr_ip4_spec,
1242 					       &perfect_filter);
1243 		break;
1244 	case TCP_V6_FLOW:
1245 		ret = ice_set_fdir_ip6_seg(seg, &fsp->m_u.tcp_ip6_spec,
1246 					   ICE_FLOW_SEG_HDR_TCP,
1247 					   &perfect_filter);
1248 		break;
1249 	case UDP_V6_FLOW:
1250 		ret = ice_set_fdir_ip6_seg(seg, &fsp->m_u.tcp_ip6_spec,
1251 					   ICE_FLOW_SEG_HDR_UDP,
1252 					   &perfect_filter);
1253 		break;
1254 	case SCTP_V6_FLOW:
1255 		ret = ice_set_fdir_ip6_seg(seg, &fsp->m_u.tcp_ip6_spec,
1256 					   ICE_FLOW_SEG_HDR_SCTP,
1257 					   &perfect_filter);
1258 		break;
1259 	case IPV6_USER_FLOW:
1260 		ret = ice_set_fdir_ip6_usr_seg(seg, &fsp->m_u.usr_ip6_spec,
1261 					       &perfect_filter);
1262 		break;
1263 	default:
1264 		ret = -EINVAL;
1265 	}
1266 	if (ret)
1267 		goto err_exit;
1268 
1269 	/* tunnel segments are shifted up one. */
1270 	memcpy(&tun_seg[1], seg, sizeof(*seg));
1271 
1272 	if (user && user->flex_fltr) {
1273 		perfect_filter = false;
1274 		ice_flow_add_fld_raw(seg, user->flex_offset,
1275 				     ICE_FLTR_PRGM_FLEX_WORD_SIZE,
1276 				     ICE_FLOW_FLD_OFF_INVAL,
1277 				     ICE_FLOW_FLD_OFF_INVAL);
1278 		ice_flow_add_fld_raw(&tun_seg[1], user->flex_offset,
1279 				     ICE_FLTR_PRGM_FLEX_WORD_SIZE,
1280 				     ICE_FLOW_FLD_OFF_INVAL,
1281 				     ICE_FLOW_FLD_OFF_INVAL);
1282 	}
1283 
1284 	fltr_idx = ice_ethtool_flow_to_fltr(fsp->flow_type & ~FLOW_EXT);
1285 
1286 	assign_bit(fltr_idx, hw->fdir_perfect_fltr, perfect_filter);
1287 
1288 	/* add filter for outer headers */
1289 	ret = ice_fdir_set_hw_fltr_rule(pf, seg, fltr_idx,
1290 					ICE_FD_HW_SEG_NON_TUN);
1291 	if (ret == -EEXIST) {
1292 		/* Rule already exists, free memory and count as success */
1293 		ret = 0;
1294 		goto err_exit;
1295 	} else if (ret) {
1296 		/* could not write filter, free memory */
1297 		goto err_exit;
1298 	}
1299 
1300 	/* make tunneled filter HW entries if possible */
1301 	memcpy(&tun_seg[1], seg, sizeof(*seg));
1302 	ret = ice_fdir_set_hw_fltr_rule(pf, tun_seg, fltr_idx,
1303 					ICE_FD_HW_SEG_TUN);
1304 	if (ret == -EEXIST) {
1305 		/* Rule already exists, free memory and count as success */
1306 		devm_kfree(dev, tun_seg);
1307 		ret = 0;
1308 	} else if (ret) {
1309 		/* could not write tunnel filter, but outer filter exists */
1310 		devm_kfree(dev, tun_seg);
1311 	}
1312 
1313 	return ret;
1314 
1315 err_exit:
1316 	devm_kfree(dev, tun_seg);
1317 	devm_kfree(dev, seg);
1318 
1319 	return ret;
1320 }
1321 
1322 /**
1323  * ice_update_per_q_fltr
1324  * @vsi: ptr to VSI
1325  * @q_index: queue index
1326  * @inc: true to increment or false to decrement per queue filter count
1327  *
1328  * This function is used to keep track of per queue sideband filters
1329  */
ice_update_per_q_fltr(struct ice_vsi * vsi,u32 q_index,bool inc)1330 static void ice_update_per_q_fltr(struct ice_vsi *vsi, u32 q_index, bool inc)
1331 {
1332 	struct ice_rx_ring *rx_ring;
1333 
1334 	if (!vsi->num_rxq || q_index >= vsi->num_rxq)
1335 		return;
1336 
1337 	rx_ring = vsi->rx_rings[q_index];
1338 	if (!rx_ring || !rx_ring->ch)
1339 		return;
1340 
1341 	if (inc)
1342 		atomic_inc(&rx_ring->ch->num_sb_fltr);
1343 	else
1344 		atomic_dec_if_positive(&rx_ring->ch->num_sb_fltr);
1345 }
1346 
1347 /**
1348  * ice_fdir_write_fltr - send a flow director filter to the hardware
1349  * @pf: PF data structure
1350  * @input: filter structure
1351  * @add: true adds filter and false removed filter
1352  * @is_tun: true adds inner filter on tunnel and false outer headers
1353  *
1354  * returns 0 on success and negative value on error
1355  */
1356 int
ice_fdir_write_fltr(struct ice_pf * pf,struct ice_fdir_fltr * input,bool add,bool is_tun)1357 ice_fdir_write_fltr(struct ice_pf *pf, struct ice_fdir_fltr *input, bool add,
1358 		    bool is_tun)
1359 {
1360 	struct device *dev = ice_pf_to_dev(pf);
1361 	struct ice_hw *hw = &pf->hw;
1362 	struct ice_fltr_desc desc;
1363 	struct ice_vsi *ctrl_vsi;
1364 	u8 *pkt, *frag_pkt;
1365 	bool has_frag;
1366 	int err;
1367 
1368 	ctrl_vsi = ice_get_ctrl_vsi(pf);
1369 	if (!ctrl_vsi)
1370 		return -EINVAL;
1371 
1372 	pkt = devm_kzalloc(dev, ICE_FDIR_MAX_RAW_PKT_SIZE, GFP_KERNEL);
1373 	if (!pkt)
1374 		return -ENOMEM;
1375 	frag_pkt = devm_kzalloc(dev, ICE_FDIR_MAX_RAW_PKT_SIZE, GFP_KERNEL);
1376 	if (!frag_pkt) {
1377 		err = -ENOMEM;
1378 		goto err_free;
1379 	}
1380 
1381 	ice_fdir_get_prgm_desc(hw, input, &desc, add);
1382 	err = ice_fdir_get_gen_prgm_pkt(hw, input, pkt, false, is_tun);
1383 	if (err)
1384 		goto err_free_all;
1385 	err = ice_prgm_fdir_fltr(ctrl_vsi, &desc, pkt);
1386 	if (err)
1387 		goto err_free_all;
1388 
1389 	/* repeat for fragment packet */
1390 	has_frag = ice_fdir_has_frag(input->flow_type);
1391 	if (has_frag) {
1392 		/* does not return error */
1393 		ice_fdir_get_prgm_desc(hw, input, &desc, add);
1394 		err = ice_fdir_get_gen_prgm_pkt(hw, input, frag_pkt, true,
1395 						is_tun);
1396 		if (err)
1397 			goto err_frag;
1398 		err = ice_prgm_fdir_fltr(ctrl_vsi, &desc, frag_pkt);
1399 		if (err)
1400 			goto err_frag;
1401 	} else {
1402 		devm_kfree(dev, frag_pkt);
1403 	}
1404 
1405 	return 0;
1406 
1407 err_free_all:
1408 	devm_kfree(dev, frag_pkt);
1409 err_free:
1410 	devm_kfree(dev, pkt);
1411 	return err;
1412 
1413 err_frag:
1414 	devm_kfree(dev, frag_pkt);
1415 	return err;
1416 }
1417 
1418 /**
1419  * ice_fdir_write_all_fltr - send a flow director filter to the hardware
1420  * @pf: PF data structure
1421  * @input: filter structure
1422  * @add: true adds filter and false removed filter
1423  *
1424  * returns 0 on success and negative value on error
1425  */
1426 static int
ice_fdir_write_all_fltr(struct ice_pf * pf,struct ice_fdir_fltr * input,bool add)1427 ice_fdir_write_all_fltr(struct ice_pf *pf, struct ice_fdir_fltr *input,
1428 			bool add)
1429 {
1430 	u16 port_num;
1431 	int tun;
1432 
1433 	for (tun = 0; tun < ICE_FD_HW_SEG_MAX; tun++) {
1434 		bool is_tun = tun == ICE_FD_HW_SEG_TUN;
1435 		int err;
1436 
1437 		if (is_tun && !ice_get_open_tunnel_port(&pf->hw, &port_num, TNL_ALL))
1438 			continue;
1439 		err = ice_fdir_write_fltr(pf, input, add, is_tun);
1440 		if (err)
1441 			return err;
1442 	}
1443 	return 0;
1444 }
1445 
1446 /**
1447  * ice_fdir_replay_fltrs - replay filters from the HW filter list
1448  * @pf: board private structure
1449  */
ice_fdir_replay_fltrs(struct ice_pf * pf)1450 void ice_fdir_replay_fltrs(struct ice_pf *pf)
1451 {
1452 	struct ice_fdir_fltr *f_rule;
1453 	struct ice_hw *hw = &pf->hw;
1454 
1455 	list_for_each_entry(f_rule, &hw->fdir_list_head, fltr_node) {
1456 		int err = ice_fdir_write_all_fltr(pf, f_rule, true);
1457 
1458 		if (err)
1459 			dev_dbg(ice_pf_to_dev(pf), "Flow Director error %d, could not reprogram filter %d\n",
1460 				err, f_rule->fltr_id);
1461 	}
1462 }
1463 
1464 /**
1465  * ice_fdir_create_dflt_rules - create default perfect filters
1466  * @pf: PF data structure
1467  *
1468  * Returns 0 for success or error.
1469  */
ice_fdir_create_dflt_rules(struct ice_pf * pf)1470 int ice_fdir_create_dflt_rules(struct ice_pf *pf)
1471 {
1472 	int err;
1473 
1474 	/* Create perfect TCP and UDP rules in hardware. */
1475 	err = ice_create_init_fdir_rule(pf, ICE_FLTR_PTYPE_NONF_IPV4_TCP);
1476 	if (err)
1477 		return err;
1478 
1479 	err = ice_create_init_fdir_rule(pf, ICE_FLTR_PTYPE_NONF_IPV4_UDP);
1480 	if (err)
1481 		return err;
1482 
1483 	err = ice_create_init_fdir_rule(pf, ICE_FLTR_PTYPE_NONF_IPV6_TCP);
1484 	if (err)
1485 		return err;
1486 
1487 	err = ice_create_init_fdir_rule(pf, ICE_FLTR_PTYPE_NONF_IPV6_UDP);
1488 
1489 	return err;
1490 }
1491 
1492 /**
1493  * ice_fdir_del_all_fltrs - Delete all flow director filters
1494  * @vsi: the VSI being changed
1495  *
1496  * This function needs to be called while holding hw->fdir_fltr_lock
1497  */
ice_fdir_del_all_fltrs(struct ice_vsi * vsi)1498 void ice_fdir_del_all_fltrs(struct ice_vsi *vsi)
1499 {
1500 	struct ice_fdir_fltr *f_rule, *tmp;
1501 	struct ice_pf *pf = vsi->back;
1502 	struct ice_hw *hw = &pf->hw;
1503 
1504 	list_for_each_entry_safe(f_rule, tmp, &hw->fdir_list_head, fltr_node) {
1505 		ice_fdir_write_all_fltr(pf, f_rule, false);
1506 		ice_fdir_update_cntrs(hw, f_rule->flow_type, false);
1507 		list_del(&f_rule->fltr_node);
1508 		devm_kfree(ice_pf_to_dev(pf), f_rule);
1509 	}
1510 }
1511 
1512 /**
1513  * ice_vsi_manage_fdir - turn on/off flow director
1514  * @vsi: the VSI being changed
1515  * @ena: boolean value indicating if this is an enable or disable request
1516  */
ice_vsi_manage_fdir(struct ice_vsi * vsi,bool ena)1517 void ice_vsi_manage_fdir(struct ice_vsi *vsi, bool ena)
1518 {
1519 	struct ice_pf *pf = vsi->back;
1520 	struct ice_hw *hw = &pf->hw;
1521 	enum ice_fltr_ptype flow;
1522 
1523 	if (ena) {
1524 		set_bit(ICE_FLAG_FD_ENA, pf->flags);
1525 		ice_fdir_create_dflt_rules(pf);
1526 		return;
1527 	}
1528 
1529 	mutex_lock(&hw->fdir_fltr_lock);
1530 	if (!test_and_clear_bit(ICE_FLAG_FD_ENA, pf->flags))
1531 		goto release_lock;
1532 
1533 	ice_fdir_del_all_fltrs(vsi);
1534 
1535 	if (hw->fdir_prof)
1536 		for (flow = ICE_FLTR_PTYPE_NONF_NONE; flow < ICE_FLTR_PTYPE_MAX;
1537 		     flow++)
1538 			if (hw->fdir_prof[flow])
1539 				ice_fdir_rem_flow(hw, ICE_BLK_FD, flow);
1540 
1541 release_lock:
1542 	mutex_unlock(&hw->fdir_fltr_lock);
1543 }
1544 
1545 /**
1546  * ice_fdir_do_rem_flow - delete flow and possibly add perfect flow
1547  * @pf: PF structure
1548  * @flow_type: FDir flow type to release
1549  */
1550 static void
ice_fdir_do_rem_flow(struct ice_pf * pf,enum ice_fltr_ptype flow_type)1551 ice_fdir_do_rem_flow(struct ice_pf *pf, enum ice_fltr_ptype flow_type)
1552 {
1553 	struct ice_hw *hw = &pf->hw;
1554 	bool need_perfect = false;
1555 
1556 	if (flow_type == ICE_FLTR_PTYPE_NONF_IPV4_TCP ||
1557 	    flow_type == ICE_FLTR_PTYPE_NONF_IPV4_UDP ||
1558 	    flow_type == ICE_FLTR_PTYPE_NONF_IPV6_TCP ||
1559 	    flow_type == ICE_FLTR_PTYPE_NONF_IPV6_UDP)
1560 		need_perfect = true;
1561 
1562 	if (need_perfect && test_bit(flow_type, hw->fdir_perfect_fltr))
1563 		return;
1564 
1565 	ice_fdir_rem_flow(hw, ICE_BLK_FD, flow_type);
1566 	if (need_perfect)
1567 		ice_create_init_fdir_rule(pf, flow_type);
1568 }
1569 
1570 /**
1571  * ice_fdir_update_list_entry - add or delete a filter from the filter list
1572  * @pf: PF structure
1573  * @input: filter structure
1574  * @fltr_idx: ethtool index of filter to modify
1575  *
1576  * returns 0 on success and negative on errors
1577  */
1578 static int
ice_fdir_update_list_entry(struct ice_pf * pf,struct ice_fdir_fltr * input,int fltr_idx)1579 ice_fdir_update_list_entry(struct ice_pf *pf, struct ice_fdir_fltr *input,
1580 			   int fltr_idx)
1581 {
1582 	struct ice_fdir_fltr *old_fltr;
1583 	struct ice_hw *hw = &pf->hw;
1584 	struct ice_vsi *vsi;
1585 	int err = -ENOENT;
1586 
1587 	/* Do not update filters during reset */
1588 	if (ice_is_reset_in_progress(pf->state))
1589 		return -EBUSY;
1590 
1591 	vsi = ice_get_main_vsi(pf);
1592 	if (!vsi)
1593 		return -EINVAL;
1594 
1595 	old_fltr = ice_fdir_find_fltr_by_idx(hw, fltr_idx);
1596 	if (old_fltr) {
1597 		err = ice_fdir_write_all_fltr(pf, old_fltr, false);
1598 		if (err)
1599 			return err;
1600 		ice_fdir_update_cntrs(hw, old_fltr->flow_type, false);
1601 		/* update sb-filters count, specific to ring->channel */
1602 		ice_update_per_q_fltr(vsi, old_fltr->orig_q_index, false);
1603 		if (!input && !hw->fdir_fltr_cnt[old_fltr->flow_type])
1604 			/* we just deleted the last filter of flow_type so we
1605 			 * should also delete the HW filter info.
1606 			 */
1607 			ice_fdir_do_rem_flow(pf, old_fltr->flow_type);
1608 		list_del(&old_fltr->fltr_node);
1609 		devm_kfree(ice_hw_to_dev(hw), old_fltr);
1610 	}
1611 	if (!input)
1612 		return err;
1613 	ice_fdir_list_add_fltr(hw, input);
1614 	/* update sb-filters count, specific to ring->channel */
1615 	ice_update_per_q_fltr(vsi, input->orig_q_index, true);
1616 	ice_fdir_update_cntrs(hw, input->flow_type, true);
1617 	return 0;
1618 }
1619 
1620 /**
1621  * ice_del_fdir_ethtool - delete Flow Director filter
1622  * @vsi: pointer to target VSI
1623  * @cmd: command to add or delete Flow Director filter
1624  *
1625  * Returns 0 on success and negative values for failure
1626  */
ice_del_fdir_ethtool(struct ice_vsi * vsi,struct ethtool_rxnfc * cmd)1627 int ice_del_fdir_ethtool(struct ice_vsi *vsi, struct ethtool_rxnfc *cmd)
1628 {
1629 	struct ethtool_rx_flow_spec *fsp =
1630 		(struct ethtool_rx_flow_spec *)&cmd->fs;
1631 	struct ice_pf *pf = vsi->back;
1632 	struct ice_hw *hw = &pf->hw;
1633 	int val;
1634 
1635 	if (!test_bit(ICE_FLAG_FD_ENA, pf->flags))
1636 		return -EOPNOTSUPP;
1637 
1638 	/* Do not delete filters during reset */
1639 	if (ice_is_reset_in_progress(pf->state)) {
1640 		dev_err(ice_pf_to_dev(pf), "Device is resetting - deleting Flow Director filters not supported during reset\n");
1641 		return -EBUSY;
1642 	}
1643 
1644 	if (test_bit(ICE_FD_FLUSH_REQ, pf->state))
1645 		return -EBUSY;
1646 
1647 	mutex_lock(&hw->fdir_fltr_lock);
1648 	val = ice_fdir_update_list_entry(pf, NULL, fsp->location);
1649 	mutex_unlock(&hw->fdir_fltr_lock);
1650 
1651 	return val;
1652 }
1653 
1654 /**
1655  * ice_update_ring_dest_vsi - update dest ring and dest VSI
1656  * @vsi: pointer to target VSI
1657  * @dest_vsi: ptr to dest VSI index
1658  * @ring: ptr to dest ring
1659  *
1660  * This function updates destination VSI and queue if user specifies
1661  * target queue which falls in channel's (aka ADQ) queue region
1662  */
1663 static void
ice_update_ring_dest_vsi(struct ice_vsi * vsi,u16 * dest_vsi,u32 * ring)1664 ice_update_ring_dest_vsi(struct ice_vsi *vsi, u16 *dest_vsi, u32 *ring)
1665 {
1666 	struct ice_channel *ch;
1667 
1668 	list_for_each_entry(ch, &vsi->ch_list, list) {
1669 		if (!ch->ch_vsi)
1670 			continue;
1671 
1672 		/* make sure to locate corresponding channel based on "queue"
1673 		 * specified
1674 		 */
1675 		if ((*ring < ch->base_q) ||
1676 		    (*ring >= (ch->base_q + ch->num_rxq)))
1677 			continue;
1678 
1679 		/* update the dest_vsi based on channel */
1680 		*dest_vsi = ch->ch_vsi->idx;
1681 
1682 		/* update the "ring" to be correct based on channel */
1683 		*ring -= ch->base_q;
1684 	}
1685 }
1686 
1687 /**
1688  * ice_set_fdir_input_set - Set the input set for Flow Director
1689  * @vsi: pointer to target VSI
1690  * @fsp: pointer to ethtool Rx flow specification
1691  * @input: filter structure
1692  */
1693 static int
ice_set_fdir_input_set(struct ice_vsi * vsi,struct ethtool_rx_flow_spec * fsp,struct ice_fdir_fltr * input)1694 ice_set_fdir_input_set(struct ice_vsi *vsi, struct ethtool_rx_flow_spec *fsp,
1695 		       struct ice_fdir_fltr *input)
1696 {
1697 	u16 dest_vsi, q_index = 0;
1698 	u16 orig_q_index = 0;
1699 	struct ice_pf *pf;
1700 	struct ice_hw *hw;
1701 	int flow_type;
1702 	u8 dest_ctl;
1703 
1704 	if (!vsi || !fsp || !input)
1705 		return -EINVAL;
1706 
1707 	pf = vsi->back;
1708 	hw = &pf->hw;
1709 
1710 	dest_vsi = vsi->idx;
1711 	if (fsp->ring_cookie == RX_CLS_FLOW_DISC) {
1712 		dest_ctl = ICE_FLTR_PRGM_DESC_DEST_DROP_PKT;
1713 	} else {
1714 		u32 ring = ethtool_get_flow_spec_ring(fsp->ring_cookie);
1715 		u8 vf = ethtool_get_flow_spec_ring_vf(fsp->ring_cookie);
1716 
1717 		if (vf) {
1718 			dev_err(ice_pf_to_dev(pf), "Failed to add filter. Flow director filters are not supported on VF queues.\n");
1719 			return -EINVAL;
1720 		}
1721 
1722 		if (ring >= vsi->num_rxq)
1723 			return -EINVAL;
1724 
1725 		orig_q_index = ring;
1726 		ice_update_ring_dest_vsi(vsi, &dest_vsi, &ring);
1727 		dest_ctl = ICE_FLTR_PRGM_DESC_DEST_DIRECT_PKT_QINDEX;
1728 		q_index = ring;
1729 	}
1730 
1731 	input->fltr_id = fsp->location;
1732 	input->q_index = q_index;
1733 	flow_type = fsp->flow_type & ~FLOW_EXT;
1734 
1735 	/* Record the original queue index as specified by user.
1736 	 * with channel configuration 'q_index' becomes relative
1737 	 * to TC (channel).
1738 	 */
1739 	input->orig_q_index = orig_q_index;
1740 	input->dest_vsi = dest_vsi;
1741 	input->dest_ctl = dest_ctl;
1742 	input->fltr_status = ICE_FLTR_PRGM_DESC_FD_STATUS_FD_ID;
1743 	input->cnt_index = ICE_FD_SB_STAT_IDX(hw->fd_ctr_base);
1744 	input->flow_type = ice_ethtool_flow_to_fltr(flow_type);
1745 
1746 	if (fsp->flow_type & FLOW_EXT) {
1747 		memcpy(input->ext_data.usr_def, fsp->h_ext.data,
1748 		       sizeof(input->ext_data.usr_def));
1749 		input->ext_data.vlan_type = fsp->h_ext.vlan_etype;
1750 		input->ext_data.vlan_tag = fsp->h_ext.vlan_tci;
1751 		memcpy(input->ext_mask.usr_def, fsp->m_ext.data,
1752 		       sizeof(input->ext_mask.usr_def));
1753 		input->ext_mask.vlan_type = fsp->m_ext.vlan_etype;
1754 		input->ext_mask.vlan_tag = fsp->m_ext.vlan_tci;
1755 	}
1756 
1757 	switch (flow_type) {
1758 	case TCP_V4_FLOW:
1759 	case UDP_V4_FLOW:
1760 	case SCTP_V4_FLOW:
1761 		input->ip.v4.dst_port = fsp->h_u.tcp_ip4_spec.pdst;
1762 		input->ip.v4.src_port = fsp->h_u.tcp_ip4_spec.psrc;
1763 		input->ip.v4.dst_ip = fsp->h_u.tcp_ip4_spec.ip4dst;
1764 		input->ip.v4.src_ip = fsp->h_u.tcp_ip4_spec.ip4src;
1765 		input->mask.v4.dst_port = fsp->m_u.tcp_ip4_spec.pdst;
1766 		input->mask.v4.src_port = fsp->m_u.tcp_ip4_spec.psrc;
1767 		input->mask.v4.dst_ip = fsp->m_u.tcp_ip4_spec.ip4dst;
1768 		input->mask.v4.src_ip = fsp->m_u.tcp_ip4_spec.ip4src;
1769 		break;
1770 	case IPV4_USER_FLOW:
1771 		input->ip.v4.dst_ip = fsp->h_u.usr_ip4_spec.ip4dst;
1772 		input->ip.v4.src_ip = fsp->h_u.usr_ip4_spec.ip4src;
1773 		input->ip.v4.l4_header = fsp->h_u.usr_ip4_spec.l4_4_bytes;
1774 		input->ip.v4.proto = fsp->h_u.usr_ip4_spec.proto;
1775 		input->ip.v4.ip_ver = fsp->h_u.usr_ip4_spec.ip_ver;
1776 		input->ip.v4.tos = fsp->h_u.usr_ip4_spec.tos;
1777 		input->mask.v4.dst_ip = fsp->m_u.usr_ip4_spec.ip4dst;
1778 		input->mask.v4.src_ip = fsp->m_u.usr_ip4_spec.ip4src;
1779 		input->mask.v4.l4_header = fsp->m_u.usr_ip4_spec.l4_4_bytes;
1780 		input->mask.v4.proto = fsp->m_u.usr_ip4_spec.proto;
1781 		input->mask.v4.ip_ver = fsp->m_u.usr_ip4_spec.ip_ver;
1782 		input->mask.v4.tos = fsp->m_u.usr_ip4_spec.tos;
1783 		break;
1784 	case TCP_V6_FLOW:
1785 	case UDP_V6_FLOW:
1786 	case SCTP_V6_FLOW:
1787 		memcpy(input->ip.v6.dst_ip, fsp->h_u.usr_ip6_spec.ip6dst,
1788 		       sizeof(struct in6_addr));
1789 		memcpy(input->ip.v6.src_ip, fsp->h_u.usr_ip6_spec.ip6src,
1790 		       sizeof(struct in6_addr));
1791 		input->ip.v6.dst_port = fsp->h_u.tcp_ip6_spec.pdst;
1792 		input->ip.v6.src_port = fsp->h_u.tcp_ip6_spec.psrc;
1793 		input->ip.v6.tc = fsp->h_u.tcp_ip6_spec.tclass;
1794 		memcpy(input->mask.v6.dst_ip, fsp->m_u.tcp_ip6_spec.ip6dst,
1795 		       sizeof(struct in6_addr));
1796 		memcpy(input->mask.v6.src_ip, fsp->m_u.tcp_ip6_spec.ip6src,
1797 		       sizeof(struct in6_addr));
1798 		input->mask.v6.dst_port = fsp->m_u.tcp_ip6_spec.pdst;
1799 		input->mask.v6.src_port = fsp->m_u.tcp_ip6_spec.psrc;
1800 		input->mask.v6.tc = fsp->m_u.tcp_ip6_spec.tclass;
1801 		break;
1802 	case IPV6_USER_FLOW:
1803 		memcpy(input->ip.v6.dst_ip, fsp->h_u.usr_ip6_spec.ip6dst,
1804 		       sizeof(struct in6_addr));
1805 		memcpy(input->ip.v6.src_ip, fsp->h_u.usr_ip6_spec.ip6src,
1806 		       sizeof(struct in6_addr));
1807 		input->ip.v6.l4_header = fsp->h_u.usr_ip6_spec.l4_4_bytes;
1808 		input->ip.v6.tc = fsp->h_u.usr_ip6_spec.tclass;
1809 
1810 		/* if no protocol requested, use IPPROTO_NONE */
1811 		if (!fsp->m_u.usr_ip6_spec.l4_proto)
1812 			input->ip.v6.proto = IPPROTO_NONE;
1813 		else
1814 			input->ip.v6.proto = fsp->h_u.usr_ip6_spec.l4_proto;
1815 
1816 		memcpy(input->mask.v6.dst_ip, fsp->m_u.usr_ip6_spec.ip6dst,
1817 		       sizeof(struct in6_addr));
1818 		memcpy(input->mask.v6.src_ip, fsp->m_u.usr_ip6_spec.ip6src,
1819 		       sizeof(struct in6_addr));
1820 		input->mask.v6.l4_header = fsp->m_u.usr_ip6_spec.l4_4_bytes;
1821 		input->mask.v6.tc = fsp->m_u.usr_ip6_spec.tclass;
1822 		input->mask.v6.proto = fsp->m_u.usr_ip6_spec.l4_proto;
1823 		break;
1824 	default:
1825 		/* not doing un-parsed flow types */
1826 		return -EINVAL;
1827 	}
1828 
1829 	return 0;
1830 }
1831 
1832 /**
1833  * ice_add_fdir_ethtool - Add/Remove Flow Director filter
1834  * @vsi: pointer to target VSI
1835  * @cmd: command to add or delete Flow Director filter
1836  *
1837  * Returns 0 on success and negative values for failure
1838  */
ice_add_fdir_ethtool(struct ice_vsi * vsi,struct ethtool_rxnfc * cmd)1839 int ice_add_fdir_ethtool(struct ice_vsi *vsi, struct ethtool_rxnfc *cmd)
1840 {
1841 	struct ice_rx_flow_userdef userdata;
1842 	struct ethtool_rx_flow_spec *fsp;
1843 	struct ice_fdir_fltr *input;
1844 	struct device *dev;
1845 	struct ice_pf *pf;
1846 	struct ice_hw *hw;
1847 	int fltrs_needed;
1848 	u16 tunnel_port;
1849 	int ret;
1850 
1851 	if (!vsi)
1852 		return -EINVAL;
1853 
1854 	pf = vsi->back;
1855 	hw = &pf->hw;
1856 	dev = ice_pf_to_dev(pf);
1857 
1858 	if (!test_bit(ICE_FLAG_FD_ENA, pf->flags))
1859 		return -EOPNOTSUPP;
1860 
1861 	/* Do not program filters during reset */
1862 	if (ice_is_reset_in_progress(pf->state)) {
1863 		dev_err(dev, "Device is resetting - adding Flow Director filters not supported during reset\n");
1864 		return -EBUSY;
1865 	}
1866 
1867 	fsp = (struct ethtool_rx_flow_spec *)&cmd->fs;
1868 
1869 	if (ice_parse_rx_flow_user_data(fsp, &userdata))
1870 		return -EINVAL;
1871 
1872 	if (fsp->flow_type & FLOW_MAC_EXT)
1873 		return -EINVAL;
1874 
1875 	ret = ice_cfg_fdir_xtrct_seq(pf, fsp, &userdata);
1876 	if (ret)
1877 		return ret;
1878 
1879 	if (fsp->location >= ice_get_fdir_cnt_all(hw)) {
1880 		dev_err(dev, "Failed to add filter.  The maximum number of flow director filters has been reached.\n");
1881 		return -ENOSPC;
1882 	}
1883 
1884 	/* return error if not an update and no available filters */
1885 	fltrs_needed = ice_get_open_tunnel_port(hw, &tunnel_port, TNL_ALL) ? 2 : 1;
1886 	if (!ice_fdir_find_fltr_by_idx(hw, fsp->location) &&
1887 	    ice_fdir_num_avail_fltr(hw, pf->vsi[vsi->idx]) < fltrs_needed) {
1888 		dev_err(dev, "Failed to add filter.  The maximum number of flow director filters has been reached.\n");
1889 		return -ENOSPC;
1890 	}
1891 
1892 	input = devm_kzalloc(dev, sizeof(*input), GFP_KERNEL);
1893 	if (!input)
1894 		return -ENOMEM;
1895 
1896 	ret = ice_set_fdir_input_set(vsi, fsp, input);
1897 	if (ret)
1898 		goto free_input;
1899 
1900 	mutex_lock(&hw->fdir_fltr_lock);
1901 	if (ice_fdir_is_dup_fltr(hw, input)) {
1902 		ret = -EINVAL;
1903 		goto release_lock;
1904 	}
1905 
1906 	if (userdata.flex_fltr) {
1907 		input->flex_fltr = true;
1908 		input->flex_word = cpu_to_be16(userdata.flex_word);
1909 		input->flex_offset = userdata.flex_offset;
1910 	}
1911 
1912 	input->cnt_ena = ICE_FXD_FLTR_QW0_STAT_ENA_PKTS;
1913 	input->fdid_prio = ICE_FXD_FLTR_QW1_FDID_PRI_THREE;
1914 	input->comp_report = ICE_FXD_FLTR_QW0_COMP_REPORT_SW_FAIL;
1915 
1916 	/* input struct is added to the HW filter list */
1917 	ret = ice_fdir_update_list_entry(pf, input, fsp->location);
1918 	if (ret)
1919 		goto release_lock;
1920 
1921 	ret = ice_fdir_write_all_fltr(pf, input, true);
1922 	if (ret)
1923 		goto remove_sw_rule;
1924 
1925 	goto release_lock;
1926 
1927 remove_sw_rule:
1928 	ice_fdir_update_cntrs(hw, input->flow_type, false);
1929 	/* update sb-filters count, specific to ring->channel */
1930 	ice_update_per_q_fltr(vsi, input->orig_q_index, false);
1931 	list_del(&input->fltr_node);
1932 release_lock:
1933 	mutex_unlock(&hw->fdir_fltr_lock);
1934 free_input:
1935 	if (ret)
1936 		devm_kfree(dev, input);
1937 
1938 	return ret;
1939 }
1940