Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0
2/* Copyright (C) 2021-2023, Intel Corporation. */
3
4#include "ice.h"
5#include "ice_base.h"
6#include "ice_lib.h"
7#include "ice_flow.h"
8#include "ice_vf_lib_private.h"
9
10#define to_fltr_conf_from_desc(p) \
11 container_of(p, struct virtchnl_fdir_fltr_conf, input)
12
13#define GTPU_TEID_OFFSET 4
14#define GTPU_EH_QFI_OFFSET 1
15#define GTPU_EH_QFI_MASK 0x3F
16#define PFCP_S_OFFSET 0
17#define PFCP_S_MASK 0x1
18#define PFCP_PORT_NR 8805
19
20#define FDIR_INSET_FLAG_ESP_S 0
21#define FDIR_INSET_FLAG_ESP_M BIT_ULL(FDIR_INSET_FLAG_ESP_S)
22#define FDIR_INSET_FLAG_ESP_UDP BIT_ULL(FDIR_INSET_FLAG_ESP_S)
23#define FDIR_INSET_FLAG_ESP_IPSEC (0ULL << FDIR_INSET_FLAG_ESP_S)
24
25enum ice_fdir_tunnel_type {
26 ICE_FDIR_TUNNEL_TYPE_NONE = 0,
27 ICE_FDIR_TUNNEL_TYPE_GTPU,
28 ICE_FDIR_TUNNEL_TYPE_GTPU_EH,
29 ICE_FDIR_TUNNEL_TYPE_ECPRI,
30 ICE_FDIR_TUNNEL_TYPE_GTPU_INNER,
31 ICE_FDIR_TUNNEL_TYPE_GTPU_EH_INNER,
32 ICE_FDIR_TUNNEL_TYPE_GRE,
33 ICE_FDIR_TUNNEL_TYPE_GTPOGRE,
34 ICE_FDIR_TUNNEL_TYPE_GTPOGRE_INNER,
35 ICE_FDIR_TUNNEL_TYPE_GRE_INNER,
36 ICE_FDIR_TUNNEL_TYPE_L2TPV2,
37 ICE_FDIR_TUNNEL_TYPE_L2TPV2_INNER,
38};
39
40struct virtchnl_fdir_fltr_conf {
41 struct ice_fdir_fltr input;
42 enum ice_fdir_tunnel_type ttype;
43 u64 inset_flag;
44 u32 flow_id;
45
46 struct ice_parser_profile *prof;
47 bool parser_ena;
48 u8 *pkt_buf;
49 u8 pkt_len;
50};
51
52struct virtchnl_fdir_inset_map {
53 enum virtchnl_proto_hdr_field field;
54 enum ice_flow_field fld;
55 u64 flag;
56 u64 mask;
57};
58
59static const struct virtchnl_fdir_inset_map fdir_inset_map[] = {
60 {VIRTCHNL_PROTO_HDR_ETH_ETHERTYPE, ICE_FLOW_FIELD_IDX_ETH_TYPE, 0, 0},
61 {VIRTCHNL_PROTO_HDR_IPV4_SRC, ICE_FLOW_FIELD_IDX_IPV4_SA, 0, 0},
62 {VIRTCHNL_PROTO_HDR_IPV4_DST, ICE_FLOW_FIELD_IDX_IPV4_DA, 0, 0},
63 {VIRTCHNL_PROTO_HDR_IPV4_DSCP, ICE_FLOW_FIELD_IDX_IPV4_DSCP, 0, 0},
64 {VIRTCHNL_PROTO_HDR_IPV4_TTL, ICE_FLOW_FIELD_IDX_IPV4_TTL, 0, 0},
65 {VIRTCHNL_PROTO_HDR_IPV4_PROT, ICE_FLOW_FIELD_IDX_IPV4_PROT, 0, 0},
66 {VIRTCHNL_PROTO_HDR_IPV6_SRC, ICE_FLOW_FIELD_IDX_IPV6_SA, 0, 0},
67 {VIRTCHNL_PROTO_HDR_IPV6_DST, ICE_FLOW_FIELD_IDX_IPV6_DA, 0, 0},
68 {VIRTCHNL_PROTO_HDR_IPV6_TC, ICE_FLOW_FIELD_IDX_IPV6_DSCP, 0, 0},
69 {VIRTCHNL_PROTO_HDR_IPV6_HOP_LIMIT, ICE_FLOW_FIELD_IDX_IPV6_TTL, 0, 0},
70 {VIRTCHNL_PROTO_HDR_IPV6_PROT, ICE_FLOW_FIELD_IDX_IPV6_PROT, 0, 0},
71 {VIRTCHNL_PROTO_HDR_UDP_SRC_PORT, ICE_FLOW_FIELD_IDX_UDP_SRC_PORT, 0, 0},
72 {VIRTCHNL_PROTO_HDR_UDP_DST_PORT, ICE_FLOW_FIELD_IDX_UDP_DST_PORT, 0, 0},
73 {VIRTCHNL_PROTO_HDR_TCP_SRC_PORT, ICE_FLOW_FIELD_IDX_TCP_SRC_PORT, 0, 0},
74 {VIRTCHNL_PROTO_HDR_TCP_DST_PORT, ICE_FLOW_FIELD_IDX_TCP_DST_PORT, 0, 0},
75 {VIRTCHNL_PROTO_HDR_SCTP_SRC_PORT, ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT, 0, 0},
76 {VIRTCHNL_PROTO_HDR_SCTP_DST_PORT, ICE_FLOW_FIELD_IDX_SCTP_DST_PORT, 0, 0},
77 {VIRTCHNL_PROTO_HDR_GTPU_IP_TEID, ICE_FLOW_FIELD_IDX_GTPU_IP_TEID, 0, 0},
78 {VIRTCHNL_PROTO_HDR_GTPU_EH_QFI, ICE_FLOW_FIELD_IDX_GTPU_EH_QFI, 0, 0},
79 {VIRTCHNL_PROTO_HDR_ESP_SPI, ICE_FLOW_FIELD_IDX_ESP_SPI,
80 FDIR_INSET_FLAG_ESP_IPSEC, FDIR_INSET_FLAG_ESP_M},
81 {VIRTCHNL_PROTO_HDR_ESP_SPI, ICE_FLOW_FIELD_IDX_NAT_T_ESP_SPI,
82 FDIR_INSET_FLAG_ESP_UDP, FDIR_INSET_FLAG_ESP_M},
83 {VIRTCHNL_PROTO_HDR_AH_SPI, ICE_FLOW_FIELD_IDX_AH_SPI, 0, 0},
84 {VIRTCHNL_PROTO_HDR_L2TPV3_SESS_ID, ICE_FLOW_FIELD_IDX_L2TPV3_SESS_ID, 0, 0},
85 {VIRTCHNL_PROTO_HDR_PFCP_S_FIELD, ICE_FLOW_FIELD_IDX_UDP_DST_PORT, 0, 0},
86};
87
88/**
89 * ice_vc_fdir_param_check
90 * @vf: pointer to the VF structure
91 * @vsi_id: VF relative VSI ID
92 *
93 * Check for the valid VSI ID, PF's state and VF's state
94 *
95 * Return: 0 on success, and -EINVAL on error.
96 */
97static int
98ice_vc_fdir_param_check(struct ice_vf *vf, u16 vsi_id)
99{
100 struct ice_pf *pf = vf->pf;
101
102 if (!test_bit(ICE_FLAG_FD_ENA, pf->flags))
103 return -EINVAL;
104
105 if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states))
106 return -EINVAL;
107
108 if (!(vf->driver_caps & VIRTCHNL_VF_OFFLOAD_FDIR_PF))
109 return -EINVAL;
110
111 if (!ice_vc_isvalid_vsi_id(vf, vsi_id))
112 return -EINVAL;
113
114 if (!ice_get_vf_vsi(vf))
115 return -EINVAL;
116
117 return 0;
118}
119
120/**
121 * ice_vf_start_ctrl_vsi
122 * @vf: pointer to the VF structure
123 *
124 * Allocate ctrl_vsi for the first time and open the ctrl_vsi port for VF
125 *
126 * Return: 0 on success, and other on error.
127 */
128static int ice_vf_start_ctrl_vsi(struct ice_vf *vf)
129{
130 struct ice_pf *pf = vf->pf;
131 struct ice_vsi *ctrl_vsi;
132 struct device *dev;
133 int err;
134
135 dev = ice_pf_to_dev(pf);
136 if (vf->ctrl_vsi_idx != ICE_NO_VSI)
137 return -EEXIST;
138
139 ctrl_vsi = ice_vf_ctrl_vsi_setup(vf);
140 if (!ctrl_vsi) {
141 dev_dbg(dev, "Could not setup control VSI for VF %d\n",
142 vf->vf_id);
143 return -ENOMEM;
144 }
145
146 err = ice_vsi_open_ctrl(ctrl_vsi);
147 if (err) {
148 dev_dbg(dev, "Could not open control VSI for VF %d\n",
149 vf->vf_id);
150 goto err_vsi_open;
151 }
152
153 return 0;
154
155err_vsi_open:
156 ice_vsi_release(ctrl_vsi);
157 if (vf->ctrl_vsi_idx != ICE_NO_VSI) {
158 pf->vsi[vf->ctrl_vsi_idx] = NULL;
159 vf->ctrl_vsi_idx = ICE_NO_VSI;
160 }
161 return err;
162}
163
164/**
165 * ice_vc_fdir_alloc_prof - allocate profile for this filter flow type
166 * @vf: pointer to the VF structure
167 * @flow: filter flow type
168 *
169 * Return: 0 on success, and other on error.
170 */
171static int
172ice_vc_fdir_alloc_prof(struct ice_vf *vf, enum ice_fltr_ptype flow)
173{
174 struct ice_vf_fdir *fdir = &vf->fdir;
175
176 if (!fdir->fdir_prof) {
177 fdir->fdir_prof = devm_kcalloc(ice_pf_to_dev(vf->pf),
178 ICE_FLTR_PTYPE_MAX,
179 sizeof(*fdir->fdir_prof),
180 GFP_KERNEL);
181 if (!fdir->fdir_prof)
182 return -ENOMEM;
183 }
184
185 if (!fdir->fdir_prof[flow]) {
186 fdir->fdir_prof[flow] = devm_kzalloc(ice_pf_to_dev(vf->pf),
187 sizeof(**fdir->fdir_prof),
188 GFP_KERNEL);
189 if (!fdir->fdir_prof[flow])
190 return -ENOMEM;
191 }
192
193 return 0;
194}
195
196/**
197 * ice_vc_fdir_free_prof - free profile for this filter flow type
198 * @vf: pointer to the VF structure
199 * @flow: filter flow type
200 */
201static void
202ice_vc_fdir_free_prof(struct ice_vf *vf, enum ice_fltr_ptype flow)
203{
204 struct ice_vf_fdir *fdir = &vf->fdir;
205
206 if (!fdir->fdir_prof)
207 return;
208
209 if (!fdir->fdir_prof[flow])
210 return;
211
212 devm_kfree(ice_pf_to_dev(vf->pf), fdir->fdir_prof[flow]);
213 fdir->fdir_prof[flow] = NULL;
214}
215
216/**
217 * ice_vc_fdir_free_prof_all - free all the profile for this VF
218 * @vf: pointer to the VF structure
219 */
220static void ice_vc_fdir_free_prof_all(struct ice_vf *vf)
221{
222 struct ice_vf_fdir *fdir = &vf->fdir;
223 enum ice_fltr_ptype flow;
224
225 if (!fdir->fdir_prof)
226 return;
227
228 for (flow = ICE_FLTR_PTYPE_NONF_NONE; flow < ICE_FLTR_PTYPE_MAX; flow++)
229 ice_vc_fdir_free_prof(vf, flow);
230
231 devm_kfree(ice_pf_to_dev(vf->pf), fdir->fdir_prof);
232 fdir->fdir_prof = NULL;
233}
234
235/**
236 * ice_vc_fdir_parse_flow_fld
237 * @proto_hdr: virtual channel protocol filter header
238 * @conf: FDIR configuration for each filter
239 * @fld: field type array
240 * @fld_cnt: field counter
241 *
242 * Parse the virtual channel filter header and store them into field type array
243 *
244 * Return: 0 on success, and other on error.
245 */
246static int
247ice_vc_fdir_parse_flow_fld(struct virtchnl_proto_hdr *proto_hdr,
248 struct virtchnl_fdir_fltr_conf *conf,
249 enum ice_flow_field *fld, int *fld_cnt)
250{
251 struct virtchnl_proto_hdr hdr;
252 u32 i;
253
254 memcpy(&hdr, proto_hdr, sizeof(hdr));
255
256 for (i = 0; (i < ARRAY_SIZE(fdir_inset_map)) &&
257 VIRTCHNL_GET_PROTO_HDR_FIELD(&hdr); i++)
258 if (VIRTCHNL_TEST_PROTO_HDR(&hdr, fdir_inset_map[i].field)) {
259 if (fdir_inset_map[i].mask &&
260 ((fdir_inset_map[i].mask & conf->inset_flag) !=
261 fdir_inset_map[i].flag))
262 continue;
263
264 fld[*fld_cnt] = fdir_inset_map[i].fld;
265 *fld_cnt += 1;
266 if (*fld_cnt >= ICE_FLOW_FIELD_IDX_MAX)
267 return -EINVAL;
268 VIRTCHNL_DEL_PROTO_HDR_FIELD(&hdr,
269 fdir_inset_map[i].field);
270 }
271
272 return 0;
273}
274
275/**
276 * ice_vc_fdir_set_flow_fld
277 * @vf: pointer to the VF structure
278 * @fltr: virtual channel add cmd buffer
279 * @conf: FDIR configuration for each filter
280 * @seg: array of one or more packet segments that describe the flow
281 *
282 * Parse the virtual channel add msg buffer's field vector and store them into
283 * flow's packet segment field
284 *
285 * Return: 0 on success, and other on error.
286 */
287static int
288ice_vc_fdir_set_flow_fld(struct ice_vf *vf, struct virtchnl_fdir_add *fltr,
289 struct virtchnl_fdir_fltr_conf *conf,
290 struct ice_flow_seg_info *seg)
291{
292 struct virtchnl_fdir_rule *rule = &fltr->rule_cfg;
293 enum ice_flow_field fld[ICE_FLOW_FIELD_IDX_MAX];
294 struct device *dev = ice_pf_to_dev(vf->pf);
295 struct virtchnl_proto_hdrs *proto;
296 int fld_cnt = 0;
297 int i;
298
299 proto = &rule->proto_hdrs;
300 for (i = 0; i < proto->count; i++) {
301 struct virtchnl_proto_hdr *hdr = &proto->proto_hdr[i];
302 int ret;
303
304 ret = ice_vc_fdir_parse_flow_fld(hdr, conf, fld, &fld_cnt);
305 if (ret)
306 return ret;
307 }
308
309 if (fld_cnt == 0) {
310 dev_dbg(dev, "Empty input set for VF %d\n", vf->vf_id);
311 return -EINVAL;
312 }
313
314 for (i = 0; i < fld_cnt; i++)
315 ice_flow_set_fld(seg, fld[i],
316 ICE_FLOW_FLD_OFF_INVAL,
317 ICE_FLOW_FLD_OFF_INVAL,
318 ICE_FLOW_FLD_OFF_INVAL, false);
319
320 return 0;
321}
322
323/**
324 * ice_vc_fdir_set_flow_hdr - config the flow's packet segment header
325 * @vf: pointer to the VF structure
326 * @conf: FDIR configuration for each filter
327 * @seg: array of one or more packet segments that describe the flow
328 *
329 * Return: 0 on success, and other on error.
330 */
331static int
332ice_vc_fdir_set_flow_hdr(struct ice_vf *vf,
333 struct virtchnl_fdir_fltr_conf *conf,
334 struct ice_flow_seg_info *seg)
335{
336 enum ice_fltr_ptype flow = conf->input.flow_type;
337 enum ice_fdir_tunnel_type ttype = conf->ttype;
338 struct device *dev = ice_pf_to_dev(vf->pf);
339
340 switch (flow) {
341 case ICE_FLTR_PTYPE_NON_IP_L2:
342 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_ETH_NON_IP);
343 break;
344 case ICE_FLTR_PTYPE_NONF_IPV4_L2TPV3:
345 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_L2TPV3 |
346 ICE_FLOW_SEG_HDR_IPV4 |
347 ICE_FLOW_SEG_HDR_IPV_OTHER);
348 break;
349 case ICE_FLTR_PTYPE_NONF_IPV4_ESP:
350 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_ESP |
351 ICE_FLOW_SEG_HDR_IPV4 |
352 ICE_FLOW_SEG_HDR_IPV_OTHER);
353 break;
354 case ICE_FLTR_PTYPE_NONF_IPV4_AH:
355 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_AH |
356 ICE_FLOW_SEG_HDR_IPV4 |
357 ICE_FLOW_SEG_HDR_IPV_OTHER);
358 break;
359 case ICE_FLTR_PTYPE_NONF_IPV4_NAT_T_ESP:
360 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_NAT_T_ESP |
361 ICE_FLOW_SEG_HDR_IPV4 |
362 ICE_FLOW_SEG_HDR_IPV_OTHER);
363 break;
364 case ICE_FLTR_PTYPE_NONF_IPV4_PFCP_NODE:
365 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_PFCP_NODE |
366 ICE_FLOW_SEG_HDR_IPV4 |
367 ICE_FLOW_SEG_HDR_IPV_OTHER);
368 break;
369 case ICE_FLTR_PTYPE_NONF_IPV4_PFCP_SESSION:
370 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_PFCP_SESSION |
371 ICE_FLOW_SEG_HDR_IPV4 |
372 ICE_FLOW_SEG_HDR_IPV_OTHER);
373 break;
374 case ICE_FLTR_PTYPE_NONF_IPV4_OTHER:
375 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_IPV4 |
376 ICE_FLOW_SEG_HDR_IPV_OTHER);
377 break;
378 case ICE_FLTR_PTYPE_NONF_IPV4_TCP:
379 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_TCP |
380 ICE_FLOW_SEG_HDR_IPV4 |
381 ICE_FLOW_SEG_HDR_IPV_OTHER);
382 break;
383 case ICE_FLTR_PTYPE_NONF_IPV4_UDP:
384 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_UDP |
385 ICE_FLOW_SEG_HDR_IPV4 |
386 ICE_FLOW_SEG_HDR_IPV_OTHER);
387 break;
388 case ICE_FLTR_PTYPE_NONF_IPV4_GTPU_IPV4_UDP:
389 case ICE_FLTR_PTYPE_NONF_IPV4_GTPU_IPV4_TCP:
390 case ICE_FLTR_PTYPE_NONF_IPV4_GTPU_IPV4_ICMP:
391 case ICE_FLTR_PTYPE_NONF_IPV4_GTPU_IPV4_OTHER:
392 if (ttype == ICE_FDIR_TUNNEL_TYPE_GTPU) {
393 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_GTPU_IP |
394 ICE_FLOW_SEG_HDR_IPV4 |
395 ICE_FLOW_SEG_HDR_IPV_OTHER);
396 } else if (ttype == ICE_FDIR_TUNNEL_TYPE_GTPU_EH) {
397 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_GTPU_EH |
398 ICE_FLOW_SEG_HDR_GTPU_IP |
399 ICE_FLOW_SEG_HDR_IPV4 |
400 ICE_FLOW_SEG_HDR_IPV_OTHER);
401 } else {
402 dev_dbg(dev, "Invalid tunnel type 0x%x for VF %d\n",
403 flow, vf->vf_id);
404 return -EINVAL;
405 }
406 break;
407 case ICE_FLTR_PTYPE_NONF_IPV4_SCTP:
408 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_SCTP |
409 ICE_FLOW_SEG_HDR_IPV4 |
410 ICE_FLOW_SEG_HDR_IPV_OTHER);
411 break;
412 case ICE_FLTR_PTYPE_NONF_IPV6_L2TPV3:
413 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_L2TPV3 |
414 ICE_FLOW_SEG_HDR_IPV6 |
415 ICE_FLOW_SEG_HDR_IPV_OTHER);
416 break;
417 case ICE_FLTR_PTYPE_NONF_IPV6_ESP:
418 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_ESP |
419 ICE_FLOW_SEG_HDR_IPV6 |
420 ICE_FLOW_SEG_HDR_IPV_OTHER);
421 break;
422 case ICE_FLTR_PTYPE_NONF_IPV6_AH:
423 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_AH |
424 ICE_FLOW_SEG_HDR_IPV6 |
425 ICE_FLOW_SEG_HDR_IPV_OTHER);
426 break;
427 case ICE_FLTR_PTYPE_NONF_IPV6_NAT_T_ESP:
428 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_NAT_T_ESP |
429 ICE_FLOW_SEG_HDR_IPV6 |
430 ICE_FLOW_SEG_HDR_IPV_OTHER);
431 break;
432 case ICE_FLTR_PTYPE_NONF_IPV6_PFCP_NODE:
433 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_PFCP_NODE |
434 ICE_FLOW_SEG_HDR_IPV6 |
435 ICE_FLOW_SEG_HDR_IPV_OTHER);
436 break;
437 case ICE_FLTR_PTYPE_NONF_IPV6_PFCP_SESSION:
438 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_PFCP_SESSION |
439 ICE_FLOW_SEG_HDR_IPV6 |
440 ICE_FLOW_SEG_HDR_IPV_OTHER);
441 break;
442 case ICE_FLTR_PTYPE_NONF_IPV6_OTHER:
443 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_IPV6 |
444 ICE_FLOW_SEG_HDR_IPV_OTHER);
445 break;
446 case ICE_FLTR_PTYPE_NONF_IPV6_TCP:
447 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_TCP |
448 ICE_FLOW_SEG_HDR_IPV6 |
449 ICE_FLOW_SEG_HDR_IPV_OTHER);
450 break;
451 case ICE_FLTR_PTYPE_NONF_IPV6_UDP:
452 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_UDP |
453 ICE_FLOW_SEG_HDR_IPV6 |
454 ICE_FLOW_SEG_HDR_IPV_OTHER);
455 break;
456 case ICE_FLTR_PTYPE_NONF_IPV6_SCTP:
457 ICE_FLOW_SET_HDRS(seg, ICE_FLOW_SEG_HDR_SCTP |
458 ICE_FLOW_SEG_HDR_IPV6 |
459 ICE_FLOW_SEG_HDR_IPV_OTHER);
460 break;
461 default:
462 dev_dbg(dev, "Invalid flow type 0x%x for VF %d failed\n",
463 flow, vf->vf_id);
464 return -EINVAL;
465 }
466
467 return 0;
468}
469
470/**
471 * ice_vc_fdir_rem_prof - remove profile for this filter flow type
472 * @vf: pointer to the VF structure
473 * @flow: filter flow type
474 * @tun: 0 implies non-tunnel type filter, 1 implies tunnel type filter
475 */
476static void
477ice_vc_fdir_rem_prof(struct ice_vf *vf, enum ice_fltr_ptype flow, int tun)
478{
479 struct ice_vf_fdir *fdir = &vf->fdir;
480 struct ice_fd_hw_prof *vf_prof;
481 struct ice_pf *pf = vf->pf;
482 struct ice_vsi *vf_vsi;
483 struct device *dev;
484 struct ice_hw *hw;
485 u64 prof_id;
486 int i;
487
488 dev = ice_pf_to_dev(pf);
489 hw = &pf->hw;
490 if (!fdir->fdir_prof || !fdir->fdir_prof[flow])
491 return;
492
493 vf_prof = fdir->fdir_prof[flow];
494 prof_id = vf_prof->prof_id[tun];
495
496 vf_vsi = ice_get_vf_vsi(vf);
497 if (!vf_vsi) {
498 dev_dbg(dev, "NULL vf %d vsi pointer\n", vf->vf_id);
499 return;
500 }
501
502 if (!fdir->prof_entry_cnt[flow][tun])
503 return;
504
505 for (i = 0; i < fdir->prof_entry_cnt[flow][tun]; i++)
506 if (vf_prof->entry_h[i][tun]) {
507 u16 vsi_num = ice_get_hw_vsi_num(hw, vf_prof->vsi_h[i]);
508
509 ice_rem_prof_id_flow(hw, ICE_BLK_FD, vsi_num, prof_id);
510 ice_flow_rem_entry(hw, ICE_BLK_FD,
511 vf_prof->entry_h[i][tun]);
512 vf_prof->entry_h[i][tun] = 0;
513 }
514
515 ice_flow_rem_prof(hw, ICE_BLK_FD, prof_id);
516 devm_kfree(dev, vf_prof->fdir_seg[tun]);
517 vf_prof->fdir_seg[tun] = NULL;
518
519 for (i = 0; i < vf_prof->cnt; i++)
520 vf_prof->vsi_h[i] = 0;
521
522 fdir->prof_entry_cnt[flow][tun] = 0;
523}
524
525/**
526 * ice_vc_fdir_rem_prof_all - remove profile for this VF
527 * @vf: pointer to the VF structure
528 */
529static void ice_vc_fdir_rem_prof_all(struct ice_vf *vf)
530{
531 enum ice_fltr_ptype flow;
532
533 for (flow = ICE_FLTR_PTYPE_NONF_NONE;
534 flow < ICE_FLTR_PTYPE_MAX; flow++) {
535 ice_vc_fdir_rem_prof(vf, flow, 0);
536 ice_vc_fdir_rem_prof(vf, flow, 1);
537 }
538}
539
540/**
541 * ice_vc_fdir_reset_cnt_all - reset all FDIR counters for this VF FDIR
542 * @fdir: pointer to the VF FDIR structure
543 */
544static void ice_vc_fdir_reset_cnt_all(struct ice_vf_fdir *fdir)
545{
546 enum ice_fltr_ptype flow;
547
548 for (flow = ICE_FLTR_PTYPE_NONF_NONE;
549 flow < ICE_FLTR_PTYPE_MAX; flow++) {
550 fdir->fdir_fltr_cnt[flow][0] = 0;
551 fdir->fdir_fltr_cnt[flow][1] = 0;
552 }
553
554 fdir->fdir_fltr_cnt_total = 0;
555}
556
557/**
558 * ice_vc_fdir_has_prof_conflict
559 * @vf: pointer to the VF structure
560 * @conf: FDIR configuration for each filter
561 *
562 * Check if @conf has conflicting profile with existing profiles
563 *
564 * Return: true on success, and false on error.
565 */
566static bool
567ice_vc_fdir_has_prof_conflict(struct ice_vf *vf,
568 struct virtchnl_fdir_fltr_conf *conf)
569{
570 struct ice_fdir_fltr *desc;
571
572 list_for_each_entry(desc, &vf->fdir.fdir_rule_list, fltr_node) {
573 struct virtchnl_fdir_fltr_conf *existing_conf;
574 enum ice_fltr_ptype flow_type_a, flow_type_b;
575 struct ice_fdir_fltr *a, *b;
576
577 existing_conf = to_fltr_conf_from_desc(desc);
578 a = &existing_conf->input;
579 b = &conf->input;
580 flow_type_a = a->flow_type;
581 flow_type_b = b->flow_type;
582
583 /* No need to compare two rules with different tunnel types or
584 * with the same protocol type.
585 */
586 if (existing_conf->ttype != conf->ttype ||
587 flow_type_a == flow_type_b)
588 continue;
589
590 switch (flow_type_a) {
591 case ICE_FLTR_PTYPE_NONF_IPV4_UDP:
592 case ICE_FLTR_PTYPE_NONF_IPV4_TCP:
593 case ICE_FLTR_PTYPE_NONF_IPV4_SCTP:
594 if (flow_type_b == ICE_FLTR_PTYPE_NONF_IPV4_OTHER)
595 return true;
596 break;
597 case ICE_FLTR_PTYPE_NONF_IPV4_OTHER:
598 if (flow_type_b == ICE_FLTR_PTYPE_NONF_IPV4_UDP ||
599 flow_type_b == ICE_FLTR_PTYPE_NONF_IPV4_TCP ||
600 flow_type_b == ICE_FLTR_PTYPE_NONF_IPV4_SCTP)
601 return true;
602 break;
603 case ICE_FLTR_PTYPE_NONF_IPV6_UDP:
604 case ICE_FLTR_PTYPE_NONF_IPV6_TCP:
605 case ICE_FLTR_PTYPE_NONF_IPV6_SCTP:
606 if (flow_type_b == ICE_FLTR_PTYPE_NONF_IPV6_OTHER)
607 return true;
608 break;
609 case ICE_FLTR_PTYPE_NONF_IPV6_OTHER:
610 if (flow_type_b == ICE_FLTR_PTYPE_NONF_IPV6_UDP ||
611 flow_type_b == ICE_FLTR_PTYPE_NONF_IPV6_TCP ||
612 flow_type_b == ICE_FLTR_PTYPE_NONF_IPV6_SCTP)
613 return true;
614 break;
615 default:
616 break;
617 }
618 }
619
620 return false;
621}
622
623/**
624 * ice_vc_fdir_write_flow_prof
625 * @vf: pointer to the VF structure
626 * @flow: filter flow type
627 * @seg: array of one or more packet segments that describe the flow
628 * @tun: 0 implies non-tunnel type filter, 1 implies tunnel type filter
629 *
630 * Write the flow's profile config and packet segment into the hardware
631 *
632 * Return: 0 on success, and other on error.
633 */
634static int
635ice_vc_fdir_write_flow_prof(struct ice_vf *vf, enum ice_fltr_ptype flow,
636 struct ice_flow_seg_info *seg, int tun)
637{
638 struct ice_vf_fdir *fdir = &vf->fdir;
639 struct ice_vsi *vf_vsi, *ctrl_vsi;
640 struct ice_flow_seg_info *old_seg;
641 struct ice_flow_prof *prof = NULL;
642 struct ice_fd_hw_prof *vf_prof;
643 struct device *dev;
644 struct ice_pf *pf;
645 struct ice_hw *hw;
646 u64 entry1_h = 0;
647 u64 entry2_h = 0;
648 int ret;
649
650 pf = vf->pf;
651 dev = ice_pf_to_dev(pf);
652 hw = &pf->hw;
653 vf_vsi = ice_get_vf_vsi(vf);
654 if (!vf_vsi)
655 return -EINVAL;
656
657 ctrl_vsi = pf->vsi[vf->ctrl_vsi_idx];
658 if (!ctrl_vsi)
659 return -EINVAL;
660
661 vf_prof = fdir->fdir_prof[flow];
662 old_seg = vf_prof->fdir_seg[tun];
663 if (old_seg) {
664 if (!memcmp(old_seg, seg, sizeof(*seg))) {
665 dev_dbg(dev, "Duplicated profile for VF %d!\n",
666 vf->vf_id);
667 return -EEXIST;
668 }
669
670 if (fdir->fdir_fltr_cnt[flow][tun]) {
671 ret = -EINVAL;
672 dev_dbg(dev, "Input set conflicts for VF %d\n",
673 vf->vf_id);
674 goto err_exit;
675 }
676
677 /* remove previously allocated profile */
678 ice_vc_fdir_rem_prof(vf, flow, tun);
679 }
680
681 ret = ice_flow_add_prof(hw, ICE_BLK_FD, ICE_FLOW_RX, seg,
682 tun + 1, false, &prof);
683 if (ret) {
684 dev_dbg(dev, "Could not add VSI flow 0x%x for VF %d\n",
685 flow, vf->vf_id);
686 goto err_exit;
687 }
688
689 ret = ice_flow_add_entry(hw, ICE_BLK_FD, prof->id, vf_vsi->idx,
690 vf_vsi->idx, ICE_FLOW_PRIO_NORMAL,
691 seg, &entry1_h);
692 if (ret) {
693 dev_dbg(dev, "Could not add flow 0x%x VSI entry for VF %d\n",
694 flow, vf->vf_id);
695 goto err_prof;
696 }
697
698 ret = ice_flow_add_entry(hw, ICE_BLK_FD, prof->id, vf_vsi->idx,
699 ctrl_vsi->idx, ICE_FLOW_PRIO_NORMAL,
700 seg, &entry2_h);
701 if (ret) {
702 dev_dbg(dev,
703 "Could not add flow 0x%x Ctrl VSI entry for VF %d\n",
704 flow, vf->vf_id);
705 goto err_entry_1;
706 }
707
708 vf_prof->fdir_seg[tun] = seg;
709 vf_prof->cnt = 0;
710 fdir->prof_entry_cnt[flow][tun] = 0;
711
712 vf_prof->entry_h[vf_prof->cnt][tun] = entry1_h;
713 vf_prof->vsi_h[vf_prof->cnt] = vf_vsi->idx;
714 vf_prof->cnt++;
715 fdir->prof_entry_cnt[flow][tun]++;
716
717 vf_prof->entry_h[vf_prof->cnt][tun] = entry2_h;
718 vf_prof->vsi_h[vf_prof->cnt] = ctrl_vsi->idx;
719 vf_prof->cnt++;
720 fdir->prof_entry_cnt[flow][tun]++;
721
722 vf_prof->prof_id[tun] = prof->id;
723
724 return 0;
725
726err_entry_1:
727 ice_rem_prof_id_flow(hw, ICE_BLK_FD,
728 ice_get_hw_vsi_num(hw, vf_vsi->idx), prof->id);
729 ice_flow_rem_entry(hw, ICE_BLK_FD, entry1_h);
730err_prof:
731 ice_flow_rem_prof(hw, ICE_BLK_FD, prof->id);
732err_exit:
733 return ret;
734}
735
736/**
737 * ice_vc_fdir_config_input_set
738 * @vf: pointer to the VF structure
739 * @fltr: virtual channel add cmd buffer
740 * @conf: FDIR configuration for each filter
741 * @tun: 0 implies non-tunnel type filter, 1 implies tunnel type filter
742 *
743 * Config the input set type and value for virtual channel add msg buffer
744 *
745 * Return: 0 on success, and other on error.
746 */
747static int
748ice_vc_fdir_config_input_set(struct ice_vf *vf, struct virtchnl_fdir_add *fltr,
749 struct virtchnl_fdir_fltr_conf *conf, int tun)
750{
751 struct ice_fdir_fltr *input = &conf->input;
752 struct device *dev = ice_pf_to_dev(vf->pf);
753 struct ice_flow_seg_info *seg;
754 enum ice_fltr_ptype flow;
755 int ret;
756
757 ret = ice_vc_fdir_has_prof_conflict(vf, conf);
758 if (ret) {
759 dev_dbg(dev, "Found flow profile conflict for VF %d\n",
760 vf->vf_id);
761 return ret;
762 }
763
764 flow = input->flow_type;
765 ret = ice_vc_fdir_alloc_prof(vf, flow);
766 if (ret) {
767 dev_dbg(dev, "Alloc flow prof for VF %d failed\n", vf->vf_id);
768 return ret;
769 }
770
771 seg = devm_kzalloc(dev, sizeof(*seg), GFP_KERNEL);
772 if (!seg)
773 return -ENOMEM;
774
775 ret = ice_vc_fdir_set_flow_fld(vf, fltr, conf, seg);
776 if (ret) {
777 dev_dbg(dev, "Set flow field for VF %d failed\n", vf->vf_id);
778 goto err_exit;
779 }
780
781 ret = ice_vc_fdir_set_flow_hdr(vf, conf, seg);
782 if (ret) {
783 dev_dbg(dev, "Set flow hdr for VF %d failed\n", vf->vf_id);
784 goto err_exit;
785 }
786
787 ret = ice_vc_fdir_write_flow_prof(vf, flow, seg, tun);
788 if (ret == -EEXIST) {
789 devm_kfree(dev, seg);
790 } else if (ret) {
791 dev_dbg(dev, "Write flow profile for VF %d failed\n",
792 vf->vf_id);
793 goto err_exit;
794 }
795
796 return 0;
797
798err_exit:
799 devm_kfree(dev, seg);
800 return ret;
801}
802
803/**
804 * ice_vc_fdir_is_raw_flow - check if FDIR flow is raw (binary)
805 * @proto: virtchnl protocol headers
806 *
807 * Check if the FDIR rule is raw flow (protocol agnostic flow) or not. Note
808 * that common FDIR rule must have non-zero proto->count. Thus, we choose the
809 * tunnel_level and count of proto as the indicators. If both tunnel_level and
810 * count of proto are zero, this FDIR rule will be regarded as raw flow.
811 *
812 * Returns: true if headers describe raw flow, false otherwise.
813 */
814static bool
815ice_vc_fdir_is_raw_flow(struct virtchnl_proto_hdrs *proto)
816{
817 return (proto->tunnel_level == 0 && proto->count == 0);
818}
819
820/**
821 * ice_vc_fdir_parse_raw - parse a virtchnl raw FDIR rule
822 * @vf: pointer to the VF info
823 * @proto: virtchnl protocol headers
824 * @conf: FDIR configuration for each filter
825 *
826 * Parse the virtual channel filter's raw flow and store it in @conf
827 *
828 * Return: 0 on success or negative errno on failure.
829 */
830static int
831ice_vc_fdir_parse_raw(struct ice_vf *vf,
832 struct virtchnl_proto_hdrs *proto,
833 struct virtchnl_fdir_fltr_conf *conf)
834{
835 u8 *pkt_buf, *msk_buf __free(kfree);
836 struct ice_parser_result rslt;
837 struct ice_pf *pf = vf->pf;
838 struct ice_parser *psr;
839 int status = -ENOMEM;
840 struct ice_hw *hw;
841 u16 udp_port = 0;
842
843 pkt_buf = kzalloc(proto->raw.pkt_len, GFP_KERNEL);
844 msk_buf = kzalloc(proto->raw.pkt_len, GFP_KERNEL);
845 if (!pkt_buf || !msk_buf)
846 goto err_mem_alloc;
847
848 memcpy(pkt_buf, proto->raw.spec, proto->raw.pkt_len);
849 memcpy(msk_buf, proto->raw.mask, proto->raw.pkt_len);
850
851 hw = &pf->hw;
852
853 /* Get raw profile info via Parser Lib */
854 psr = ice_parser_create(hw);
855 if (IS_ERR(psr)) {
856 status = PTR_ERR(psr);
857 goto err_mem_alloc;
858 }
859
860 ice_parser_dvm_set(psr, ice_is_dvm_ena(hw));
861
862 if (ice_get_open_tunnel_port(hw, &udp_port, TNL_VXLAN))
863 ice_parser_vxlan_tunnel_set(psr, udp_port, true);
864
865 status = ice_parser_run(psr, pkt_buf, proto->raw.pkt_len, &rslt);
866 if (status)
867 goto err_parser_destroy;
868
869 if (hw->debug_mask & ICE_DBG_PARSER)
870 ice_parser_result_dump(hw, &rslt);
871
872 conf->prof = kzalloc(sizeof(*conf->prof), GFP_KERNEL);
873 if (!conf->prof) {
874 status = -ENOMEM;
875 goto err_parser_destroy;
876 }
877
878 status = ice_parser_profile_init(&rslt, pkt_buf, msk_buf,
879 proto->raw.pkt_len, ICE_BLK_FD,
880 conf->prof);
881 if (status)
882 goto err_parser_profile_init;
883
884 if (hw->debug_mask & ICE_DBG_PARSER)
885 ice_parser_profile_dump(hw, conf->prof);
886
887 /* Store raw flow info into @conf */
888 conf->pkt_len = proto->raw.pkt_len;
889 conf->pkt_buf = pkt_buf;
890 conf->parser_ena = true;
891
892 ice_parser_destroy(psr);
893 return 0;
894
895err_parser_profile_init:
896 kfree(conf->prof);
897err_parser_destroy:
898 ice_parser_destroy(psr);
899err_mem_alloc:
900 kfree(pkt_buf);
901 return status;
902}
903
904/**
905 * ice_vc_fdir_parse_pattern
906 * @vf: pointer to the VF info
907 * @fltr: virtual channel add cmd buffer
908 * @conf: FDIR configuration for each filter
909 *
910 * Parse the virtual channel filter's pattern and store them into conf
911 *
912 * Return: 0 on success, and other on error.
913 */
914static int
915ice_vc_fdir_parse_pattern(struct ice_vf *vf, struct virtchnl_fdir_add *fltr,
916 struct virtchnl_fdir_fltr_conf *conf)
917{
918 struct virtchnl_proto_hdrs *proto = &fltr->rule_cfg.proto_hdrs;
919 enum virtchnl_proto_hdr_type l3 = VIRTCHNL_PROTO_HDR_NONE;
920 enum virtchnl_proto_hdr_type l4 = VIRTCHNL_PROTO_HDR_NONE;
921 struct device *dev = ice_pf_to_dev(vf->pf);
922 struct ice_fdir_fltr *input = &conf->input;
923 int i;
924
925 if (proto->count > VIRTCHNL_MAX_NUM_PROTO_HDRS) {
926 dev_dbg(dev, "Invalid protocol count:0x%x for VF %d\n",
927 proto->count, vf->vf_id);
928 return -EINVAL;
929 }
930
931 /* For raw FDIR filters created by the parser */
932 if (ice_vc_fdir_is_raw_flow(proto))
933 return ice_vc_fdir_parse_raw(vf, proto, conf);
934
935 for (i = 0; i < proto->count; i++) {
936 struct virtchnl_proto_hdr *hdr = &proto->proto_hdr[i];
937 struct ip_esp_hdr *esph;
938 struct ip_auth_hdr *ah;
939 struct sctphdr *sctph;
940 struct ipv6hdr *ip6h;
941 struct udphdr *udph;
942 struct tcphdr *tcph;
943 struct ethhdr *eth;
944 struct iphdr *iph;
945 u8 s_field;
946 u8 *rawh;
947
948 switch (hdr->type) {
949 case VIRTCHNL_PROTO_HDR_ETH:
950 eth = (struct ethhdr *)hdr->buffer;
951 input->flow_type = ICE_FLTR_PTYPE_NON_IP_L2;
952
953 if (hdr->field_selector)
954 input->ext_data.ether_type = eth->h_proto;
955 break;
956 case VIRTCHNL_PROTO_HDR_IPV4:
957 iph = (struct iphdr *)hdr->buffer;
958 l3 = VIRTCHNL_PROTO_HDR_IPV4;
959 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV4_OTHER;
960
961 if (hdr->field_selector) {
962 input->ip.v4.src_ip = iph->saddr;
963 input->ip.v4.dst_ip = iph->daddr;
964 input->ip.v4.tos = iph->tos;
965 input->ip.v4.proto = iph->protocol;
966 }
967 break;
968 case VIRTCHNL_PROTO_HDR_IPV6:
969 ip6h = (struct ipv6hdr *)hdr->buffer;
970 l3 = VIRTCHNL_PROTO_HDR_IPV6;
971 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV6_OTHER;
972
973 if (hdr->field_selector) {
974 memcpy(input->ip.v6.src_ip,
975 ip6h->saddr.in6_u.u6_addr8,
976 sizeof(ip6h->saddr));
977 memcpy(input->ip.v6.dst_ip,
978 ip6h->daddr.in6_u.u6_addr8,
979 sizeof(ip6h->daddr));
980 input->ip.v6.tc = ((u8)(ip6h->priority) << 4) |
981 (ip6h->flow_lbl[0] >> 4);
982 input->ip.v6.proto = ip6h->nexthdr;
983 }
984 break;
985 case VIRTCHNL_PROTO_HDR_TCP:
986 tcph = (struct tcphdr *)hdr->buffer;
987 if (l3 == VIRTCHNL_PROTO_HDR_IPV4)
988 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV4_TCP;
989 else if (l3 == VIRTCHNL_PROTO_HDR_IPV6)
990 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV6_TCP;
991
992 if (hdr->field_selector) {
993 if (l3 == VIRTCHNL_PROTO_HDR_IPV4) {
994 input->ip.v4.src_port = tcph->source;
995 input->ip.v4.dst_port = tcph->dest;
996 } else if (l3 == VIRTCHNL_PROTO_HDR_IPV6) {
997 input->ip.v6.src_port = tcph->source;
998 input->ip.v6.dst_port = tcph->dest;
999 }
1000 }
1001 break;
1002 case VIRTCHNL_PROTO_HDR_UDP:
1003 udph = (struct udphdr *)hdr->buffer;
1004 if (l3 == VIRTCHNL_PROTO_HDR_IPV4)
1005 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV4_UDP;
1006 else if (l3 == VIRTCHNL_PROTO_HDR_IPV6)
1007 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV6_UDP;
1008
1009 if (hdr->field_selector) {
1010 if (l3 == VIRTCHNL_PROTO_HDR_IPV4) {
1011 input->ip.v4.src_port = udph->source;
1012 input->ip.v4.dst_port = udph->dest;
1013 } else if (l3 == VIRTCHNL_PROTO_HDR_IPV6) {
1014 input->ip.v6.src_port = udph->source;
1015 input->ip.v6.dst_port = udph->dest;
1016 }
1017 }
1018 break;
1019 case VIRTCHNL_PROTO_HDR_SCTP:
1020 sctph = (struct sctphdr *)hdr->buffer;
1021 if (l3 == VIRTCHNL_PROTO_HDR_IPV4)
1022 input->flow_type =
1023 ICE_FLTR_PTYPE_NONF_IPV4_SCTP;
1024 else if (l3 == VIRTCHNL_PROTO_HDR_IPV6)
1025 input->flow_type =
1026 ICE_FLTR_PTYPE_NONF_IPV6_SCTP;
1027
1028 if (hdr->field_selector) {
1029 if (l3 == VIRTCHNL_PROTO_HDR_IPV4) {
1030 input->ip.v4.src_port = sctph->source;
1031 input->ip.v4.dst_port = sctph->dest;
1032 } else if (l3 == VIRTCHNL_PROTO_HDR_IPV6) {
1033 input->ip.v6.src_port = sctph->source;
1034 input->ip.v6.dst_port = sctph->dest;
1035 }
1036 }
1037 break;
1038 case VIRTCHNL_PROTO_HDR_L2TPV3:
1039 if (l3 == VIRTCHNL_PROTO_HDR_IPV4)
1040 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV4_L2TPV3;
1041 else if (l3 == VIRTCHNL_PROTO_HDR_IPV6)
1042 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV6_L2TPV3;
1043
1044 if (hdr->field_selector)
1045 input->l2tpv3_data.session_id = *((__be32 *)hdr->buffer);
1046 break;
1047 case VIRTCHNL_PROTO_HDR_ESP:
1048 esph = (struct ip_esp_hdr *)hdr->buffer;
1049 if (l3 == VIRTCHNL_PROTO_HDR_IPV4 &&
1050 l4 == VIRTCHNL_PROTO_HDR_UDP)
1051 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV4_NAT_T_ESP;
1052 else if (l3 == VIRTCHNL_PROTO_HDR_IPV6 &&
1053 l4 == VIRTCHNL_PROTO_HDR_UDP)
1054 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV6_NAT_T_ESP;
1055 else if (l3 == VIRTCHNL_PROTO_HDR_IPV4 &&
1056 l4 == VIRTCHNL_PROTO_HDR_NONE)
1057 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV4_ESP;
1058 else if (l3 == VIRTCHNL_PROTO_HDR_IPV6 &&
1059 l4 == VIRTCHNL_PROTO_HDR_NONE)
1060 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV6_ESP;
1061
1062 if (l4 == VIRTCHNL_PROTO_HDR_UDP)
1063 conf->inset_flag |= FDIR_INSET_FLAG_ESP_UDP;
1064 else
1065 conf->inset_flag |= FDIR_INSET_FLAG_ESP_IPSEC;
1066
1067 if (hdr->field_selector) {
1068 if (l3 == VIRTCHNL_PROTO_HDR_IPV4)
1069 input->ip.v4.sec_parm_idx = esph->spi;
1070 else if (l3 == VIRTCHNL_PROTO_HDR_IPV6)
1071 input->ip.v6.sec_parm_idx = esph->spi;
1072 }
1073 break;
1074 case VIRTCHNL_PROTO_HDR_AH:
1075 ah = (struct ip_auth_hdr *)hdr->buffer;
1076 if (l3 == VIRTCHNL_PROTO_HDR_IPV4)
1077 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV4_AH;
1078 else if (l3 == VIRTCHNL_PROTO_HDR_IPV6)
1079 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV6_AH;
1080
1081 if (hdr->field_selector) {
1082 if (l3 == VIRTCHNL_PROTO_HDR_IPV4)
1083 input->ip.v4.sec_parm_idx = ah->spi;
1084 else if (l3 == VIRTCHNL_PROTO_HDR_IPV6)
1085 input->ip.v6.sec_parm_idx = ah->spi;
1086 }
1087 break;
1088 case VIRTCHNL_PROTO_HDR_PFCP:
1089 rawh = (u8 *)hdr->buffer;
1090 s_field = (rawh[0] >> PFCP_S_OFFSET) & PFCP_S_MASK;
1091 if (l3 == VIRTCHNL_PROTO_HDR_IPV4 && s_field == 0)
1092 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV4_PFCP_NODE;
1093 else if (l3 == VIRTCHNL_PROTO_HDR_IPV4 && s_field == 1)
1094 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV4_PFCP_SESSION;
1095 else if (l3 == VIRTCHNL_PROTO_HDR_IPV6 && s_field == 0)
1096 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV6_PFCP_NODE;
1097 else if (l3 == VIRTCHNL_PROTO_HDR_IPV6 && s_field == 1)
1098 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV6_PFCP_SESSION;
1099
1100 if (hdr->field_selector) {
1101 if (l3 == VIRTCHNL_PROTO_HDR_IPV4)
1102 input->ip.v4.dst_port = cpu_to_be16(PFCP_PORT_NR);
1103 else if (l3 == VIRTCHNL_PROTO_HDR_IPV6)
1104 input->ip.v6.dst_port = cpu_to_be16(PFCP_PORT_NR);
1105 }
1106 break;
1107 case VIRTCHNL_PROTO_HDR_GTPU_IP:
1108 rawh = (u8 *)hdr->buffer;
1109 input->flow_type = ICE_FLTR_PTYPE_NONF_IPV4_GTPU_IPV4_OTHER;
1110
1111 if (hdr->field_selector)
1112 input->gtpu_data.teid = *(__be32 *)(&rawh[GTPU_TEID_OFFSET]);
1113 conf->ttype = ICE_FDIR_TUNNEL_TYPE_GTPU;
1114 break;
1115 case VIRTCHNL_PROTO_HDR_GTPU_EH:
1116 rawh = (u8 *)hdr->buffer;
1117
1118 if (hdr->field_selector)
1119 input->gtpu_data.qfi = rawh[GTPU_EH_QFI_OFFSET] & GTPU_EH_QFI_MASK;
1120 conf->ttype = ICE_FDIR_TUNNEL_TYPE_GTPU_EH;
1121 break;
1122 default:
1123 dev_dbg(dev, "Invalid header type 0x:%x for VF %d\n",
1124 hdr->type, vf->vf_id);
1125 return -EINVAL;
1126 }
1127 }
1128
1129 return 0;
1130}
1131
1132/**
1133 * ice_vc_fdir_parse_action
1134 * @vf: pointer to the VF info
1135 * @fltr: virtual channel add cmd buffer
1136 * @conf: FDIR configuration for each filter
1137 *
1138 * Parse the virtual channel filter's action and store them into conf
1139 *
1140 * Return: 0 on success, and other on error.
1141 */
1142static int
1143ice_vc_fdir_parse_action(struct ice_vf *vf, struct virtchnl_fdir_add *fltr,
1144 struct virtchnl_fdir_fltr_conf *conf)
1145{
1146 struct virtchnl_filter_action_set *as = &fltr->rule_cfg.action_set;
1147 struct device *dev = ice_pf_to_dev(vf->pf);
1148 struct ice_fdir_fltr *input = &conf->input;
1149 u32 dest_num = 0;
1150 u32 mark_num = 0;
1151 int i;
1152
1153 if (as->count > VIRTCHNL_MAX_NUM_ACTIONS) {
1154 dev_dbg(dev, "Invalid action numbers:0x%x for VF %d\n",
1155 as->count, vf->vf_id);
1156 return -EINVAL;
1157 }
1158
1159 for (i = 0; i < as->count; i++) {
1160 struct virtchnl_filter_action *action = &as->actions[i];
1161
1162 switch (action->type) {
1163 case VIRTCHNL_ACTION_PASSTHRU:
1164 dest_num++;
1165 input->dest_ctl = ICE_FLTR_PRGM_DESC_DEST_DIRECT_PKT_OTHER;
1166 break;
1167 case VIRTCHNL_ACTION_DROP:
1168 dest_num++;
1169 input->dest_ctl = ICE_FLTR_PRGM_DESC_DEST_DROP_PKT;
1170 break;
1171 case VIRTCHNL_ACTION_QUEUE:
1172 dest_num++;
1173 input->dest_ctl = ICE_FLTR_PRGM_DESC_DEST_DIRECT_PKT_QINDEX;
1174 input->q_index = action->act_conf.queue.index;
1175 break;
1176 case VIRTCHNL_ACTION_Q_REGION:
1177 dest_num++;
1178 input->dest_ctl = ICE_FLTR_PRGM_DESC_DEST_DIRECT_PKT_QGROUP;
1179 input->q_index = action->act_conf.queue.index;
1180 input->q_region = action->act_conf.queue.region;
1181 break;
1182 case VIRTCHNL_ACTION_MARK:
1183 mark_num++;
1184 input->fltr_id = action->act_conf.mark_id;
1185 input->fdid_prio = ICE_FXD_FLTR_QW1_FDID_PRI_THREE;
1186 break;
1187 default:
1188 dev_dbg(dev, "Invalid action type:0x%x for VF %d\n",
1189 action->type, vf->vf_id);
1190 return -EINVAL;
1191 }
1192 }
1193
1194 if (dest_num == 0 || dest_num >= 2) {
1195 dev_dbg(dev, "Invalid destination action for VF %d\n",
1196 vf->vf_id);
1197 return -EINVAL;
1198 }
1199
1200 if (mark_num >= 2) {
1201 dev_dbg(dev, "Too many mark actions for VF %d\n", vf->vf_id);
1202 return -EINVAL;
1203 }
1204
1205 return 0;
1206}
1207
1208/**
1209 * ice_vc_validate_fdir_fltr - validate the virtual channel filter
1210 * @vf: pointer to the VF info
1211 * @fltr: virtual channel add cmd buffer
1212 * @conf: FDIR configuration for each filter
1213 *
1214 * Return: 0 on success, and other on error.
1215 */
1216static int
1217ice_vc_validate_fdir_fltr(struct ice_vf *vf, struct virtchnl_fdir_add *fltr,
1218 struct virtchnl_fdir_fltr_conf *conf)
1219{
1220 struct virtchnl_proto_hdrs *proto = &fltr->rule_cfg.proto_hdrs;
1221 int ret;
1222
1223 /* For raw FDIR filters created by the parser */
1224 if (!ice_vc_fdir_is_raw_flow(proto))
1225 if (!ice_vc_validate_pattern(vf, proto))
1226 return -EINVAL;
1227
1228 ret = ice_vc_fdir_parse_pattern(vf, fltr, conf);
1229 if (ret)
1230 return ret;
1231
1232 return ice_vc_fdir_parse_action(vf, fltr, conf);
1233}
1234
1235/**
1236 * ice_vc_fdir_comp_rules - compare if two filter rules have the same value
1237 * @conf_a: FDIR configuration for filter a
1238 * @conf_b: FDIR configuration for filter b
1239 *
1240 * Return: 0 on success, and other on error.
1241 */
1242static bool
1243ice_vc_fdir_comp_rules(struct virtchnl_fdir_fltr_conf *conf_a,
1244 struct virtchnl_fdir_fltr_conf *conf_b)
1245{
1246 struct ice_fdir_fltr *a = &conf_a->input;
1247 struct ice_fdir_fltr *b = &conf_b->input;
1248
1249 if (conf_a->ttype != conf_b->ttype)
1250 return false;
1251 if (a->flow_type != b->flow_type)
1252 return false;
1253 if (memcmp(&a->ip, &b->ip, sizeof(a->ip)))
1254 return false;
1255 if (memcmp(&a->mask, &b->mask, sizeof(a->mask)))
1256 return false;
1257 if (memcmp(&a->gtpu_data, &b->gtpu_data, sizeof(a->gtpu_data)))
1258 return false;
1259 if (memcmp(&a->gtpu_mask, &b->gtpu_mask, sizeof(a->gtpu_mask)))
1260 return false;
1261 if (memcmp(&a->l2tpv3_data, &b->l2tpv3_data, sizeof(a->l2tpv3_data)))
1262 return false;
1263 if (memcmp(&a->l2tpv3_mask, &b->l2tpv3_mask, sizeof(a->l2tpv3_mask)))
1264 return false;
1265 if (memcmp(&a->ext_data, &b->ext_data, sizeof(a->ext_data)))
1266 return false;
1267 if (memcmp(&a->ext_mask, &b->ext_mask, sizeof(a->ext_mask)))
1268 return false;
1269
1270 return true;
1271}
1272
1273/**
1274 * ice_vc_fdir_is_dup_fltr
1275 * @vf: pointer to the VF info
1276 * @conf: FDIR configuration for each filter
1277 *
1278 * Check if there is duplicated rule with same conf value
1279 *
1280 * Return: 0 true success, and false on error.
1281 */
1282static bool
1283ice_vc_fdir_is_dup_fltr(struct ice_vf *vf, struct virtchnl_fdir_fltr_conf *conf)
1284{
1285 struct ice_fdir_fltr *desc;
1286 bool ret;
1287
1288 list_for_each_entry(desc, &vf->fdir.fdir_rule_list, fltr_node) {
1289 struct virtchnl_fdir_fltr_conf *node =
1290 to_fltr_conf_from_desc(desc);
1291
1292 ret = ice_vc_fdir_comp_rules(node, conf);
1293 if (ret)
1294 return true;
1295 }
1296
1297 return false;
1298}
1299
1300/**
1301 * ice_vc_fdir_insert_entry
1302 * @vf: pointer to the VF info
1303 * @conf: FDIR configuration for each filter
1304 * @id: pointer to ID value allocated by driver
1305 *
1306 * Insert FDIR conf entry into list and allocate ID for this filter
1307 *
1308 * Return: 0 true success, and other on error.
1309 */
1310static int
1311ice_vc_fdir_insert_entry(struct ice_vf *vf,
1312 struct virtchnl_fdir_fltr_conf *conf, u32 *id)
1313{
1314 struct ice_fdir_fltr *input = &conf->input;
1315 int i;
1316
1317 /* alloc ID corresponding with conf */
1318 i = idr_alloc(&vf->fdir.fdir_rule_idr, conf, 0,
1319 ICE_FDIR_MAX_FLTRS, GFP_KERNEL);
1320 if (i < 0)
1321 return -EINVAL;
1322 *id = i;
1323
1324 list_add(&input->fltr_node, &vf->fdir.fdir_rule_list);
1325 return 0;
1326}
1327
1328/**
1329 * ice_vc_fdir_remove_entry - remove FDIR conf entry by ID value
1330 * @vf: pointer to the VF info
1331 * @conf: FDIR configuration for each filter
1332 * @id: filter rule's ID
1333 */
1334static void
1335ice_vc_fdir_remove_entry(struct ice_vf *vf,
1336 struct virtchnl_fdir_fltr_conf *conf, u32 id)
1337{
1338 struct ice_fdir_fltr *input = &conf->input;
1339
1340 idr_remove(&vf->fdir.fdir_rule_idr, id);
1341 list_del(&input->fltr_node);
1342}
1343
1344/**
1345 * ice_vc_fdir_lookup_entry - lookup FDIR conf entry by ID value
1346 * @vf: pointer to the VF info
1347 * @id: filter rule's ID
1348 *
1349 * Return: NULL on error, and other on success.
1350 */
1351static struct virtchnl_fdir_fltr_conf *
1352ice_vc_fdir_lookup_entry(struct ice_vf *vf, u32 id)
1353{
1354 return idr_find(&vf->fdir.fdir_rule_idr, id);
1355}
1356
1357/**
1358 * ice_vc_fdir_flush_entry - remove all FDIR conf entry
1359 * @vf: pointer to the VF info
1360 */
1361static void ice_vc_fdir_flush_entry(struct ice_vf *vf)
1362{
1363 struct virtchnl_fdir_fltr_conf *conf;
1364 struct ice_fdir_fltr *desc, *temp;
1365
1366 list_for_each_entry_safe(desc, temp,
1367 &vf->fdir.fdir_rule_list, fltr_node) {
1368 conf = to_fltr_conf_from_desc(desc);
1369 list_del(&desc->fltr_node);
1370 devm_kfree(ice_pf_to_dev(vf->pf), conf);
1371 }
1372}
1373
1374/**
1375 * ice_vc_fdir_write_fltr - write filter rule into hardware
1376 * @vf: pointer to the VF info
1377 * @conf: FDIR configuration for each filter
1378 * @add: true implies add rule, false implies del rules
1379 * @is_tun: false implies non-tunnel type filter, true implies tunnel filter
1380 *
1381 * Return: 0 on success, and other on error.
1382 */
1383static int ice_vc_fdir_write_fltr(struct ice_vf *vf,
1384 struct virtchnl_fdir_fltr_conf *conf,
1385 bool add, bool is_tun)
1386{
1387 struct ice_fdir_fltr *input = &conf->input;
1388 struct ice_vsi *vsi, *ctrl_vsi;
1389 struct ice_fltr_desc desc;
1390 struct device *dev;
1391 struct ice_pf *pf;
1392 struct ice_hw *hw;
1393 int ret;
1394 u8 *pkt;
1395
1396 pf = vf->pf;
1397 dev = ice_pf_to_dev(pf);
1398 hw = &pf->hw;
1399 vsi = ice_get_vf_vsi(vf);
1400 if (!vsi) {
1401 dev_dbg(dev, "Invalid vsi for VF %d\n", vf->vf_id);
1402 return -EINVAL;
1403 }
1404
1405 input->dest_vsi = vsi->idx;
1406 input->comp_report = ICE_FXD_FLTR_QW0_COMP_REPORT_SW;
1407
1408 ctrl_vsi = pf->vsi[vf->ctrl_vsi_idx];
1409 if (!ctrl_vsi) {
1410 dev_dbg(dev, "Invalid ctrl_vsi for VF %d\n", vf->vf_id);
1411 return -EINVAL;
1412 }
1413
1414 pkt = devm_kzalloc(dev, ICE_FDIR_MAX_RAW_PKT_SIZE, GFP_KERNEL);
1415 if (!pkt)
1416 return -ENOMEM;
1417
1418 ice_fdir_get_prgm_desc(hw, input, &desc, add);
1419 if (conf->parser_ena) {
1420 memcpy(pkt, conf->pkt_buf, conf->pkt_len);
1421 } else {
1422 ret = ice_fdir_get_gen_prgm_pkt(hw, input, pkt, false, is_tun);
1423 if (ret) {
1424 dev_dbg(dev, "Gen training pkt for VF %d ptype %d failed\n",
1425 vf->vf_id, input->flow_type);
1426 goto err_free_pkt;
1427 }
1428 }
1429
1430 ret = ice_prgm_fdir_fltr(ctrl_vsi, &desc, pkt);
1431 if (ret)
1432 goto err_free_pkt;
1433
1434 return 0;
1435
1436err_free_pkt:
1437 devm_kfree(dev, pkt);
1438 return ret;
1439}
1440
1441/**
1442 * ice_vf_fdir_timer - FDIR program waiting timer interrupt handler
1443 * @t: pointer to timer_list
1444 */
1445static void ice_vf_fdir_timer(struct timer_list *t)
1446{
1447 struct ice_vf_fdir_ctx *ctx_irq = from_timer(ctx_irq, t, rx_tmr);
1448 struct ice_vf_fdir_ctx *ctx_done;
1449 struct ice_vf_fdir *fdir;
1450 unsigned long flags;
1451 struct ice_vf *vf;
1452 struct ice_pf *pf;
1453
1454 fdir = container_of(ctx_irq, struct ice_vf_fdir, ctx_irq);
1455 vf = container_of(fdir, struct ice_vf, fdir);
1456 ctx_done = &fdir->ctx_done;
1457 pf = vf->pf;
1458 spin_lock_irqsave(&fdir->ctx_lock, flags);
1459 if (!(ctx_irq->flags & ICE_VF_FDIR_CTX_VALID)) {
1460 spin_unlock_irqrestore(&fdir->ctx_lock, flags);
1461 WARN_ON_ONCE(1);
1462 return;
1463 }
1464
1465 ctx_irq->flags &= ~ICE_VF_FDIR_CTX_VALID;
1466
1467 ctx_done->flags |= ICE_VF_FDIR_CTX_VALID;
1468 ctx_done->conf = ctx_irq->conf;
1469 ctx_done->stat = ICE_FDIR_CTX_TIMEOUT;
1470 ctx_done->v_opcode = ctx_irq->v_opcode;
1471 spin_unlock_irqrestore(&fdir->ctx_lock, flags);
1472
1473 set_bit(ICE_FD_VF_FLUSH_CTX, pf->state);
1474 ice_service_task_schedule(pf);
1475}
1476
1477/**
1478 * ice_vc_fdir_irq_handler - ctrl_vsi Rx queue interrupt handler
1479 * @ctrl_vsi: pointer to a VF's CTRL VSI
1480 * @rx_desc: pointer to FDIR Rx queue descriptor
1481 */
1482void
1483ice_vc_fdir_irq_handler(struct ice_vsi *ctrl_vsi,
1484 union ice_32b_rx_flex_desc *rx_desc)
1485{
1486 struct ice_pf *pf = ctrl_vsi->back;
1487 struct ice_vf *vf = ctrl_vsi->vf;
1488 struct ice_vf_fdir_ctx *ctx_done;
1489 struct ice_vf_fdir_ctx *ctx_irq;
1490 struct ice_vf_fdir *fdir;
1491 unsigned long flags;
1492 struct device *dev;
1493 int ret;
1494
1495 if (WARN_ON(!vf))
1496 return;
1497
1498 fdir = &vf->fdir;
1499 ctx_done = &fdir->ctx_done;
1500 ctx_irq = &fdir->ctx_irq;
1501 dev = ice_pf_to_dev(pf);
1502 spin_lock_irqsave(&fdir->ctx_lock, flags);
1503 if (!(ctx_irq->flags & ICE_VF_FDIR_CTX_VALID)) {
1504 spin_unlock_irqrestore(&fdir->ctx_lock, flags);
1505 WARN_ON_ONCE(1);
1506 return;
1507 }
1508
1509 ctx_irq->flags &= ~ICE_VF_FDIR_CTX_VALID;
1510
1511 ctx_done->flags |= ICE_VF_FDIR_CTX_VALID;
1512 ctx_done->conf = ctx_irq->conf;
1513 ctx_done->stat = ICE_FDIR_CTX_IRQ;
1514 ctx_done->v_opcode = ctx_irq->v_opcode;
1515 memcpy(&ctx_done->rx_desc, rx_desc, sizeof(*rx_desc));
1516 spin_unlock_irqrestore(&fdir->ctx_lock, flags);
1517
1518 ret = del_timer(&ctx_irq->rx_tmr);
1519 if (!ret)
1520 dev_err(dev, "VF %d: Unexpected inactive timer!\n", vf->vf_id);
1521
1522 set_bit(ICE_FD_VF_FLUSH_CTX, pf->state);
1523 ice_service_task_schedule(pf);
1524}
1525
1526/**
1527 * ice_vf_fdir_dump_info - dump FDIR information for diagnosis
1528 * @vf: pointer to the VF info
1529 */
1530static void ice_vf_fdir_dump_info(struct ice_vf *vf)
1531{
1532 u32 fd_size, fd_cnt, fd_size_g, fd_cnt_g, fd_size_b, fd_cnt_b;
1533 struct ice_vsi *vf_vsi;
1534 struct device *dev;
1535 struct ice_pf *pf;
1536 struct ice_hw *hw;
1537 u16 vsi_num;
1538
1539 pf = vf->pf;
1540 hw = &pf->hw;
1541 dev = ice_pf_to_dev(pf);
1542 vf_vsi = ice_get_vf_vsi(vf);
1543 if (!vf_vsi) {
1544 dev_dbg(dev, "VF %d: invalid VSI pointer\n", vf->vf_id);
1545 return;
1546 }
1547
1548 vsi_num = ice_get_hw_vsi_num(hw, vf_vsi->idx);
1549
1550 fd_size = rd32(hw, VSIQF_FD_SIZE(vsi_num));
1551 fd_cnt = rd32(hw, VSIQF_FD_CNT(vsi_num));
1552 switch (hw->mac_type) {
1553 case ICE_MAC_E830:
1554 fd_size_g = FIELD_GET(E830_VSIQF_FD_CNT_FD_GCNT_M, fd_size);
1555 fd_size_b = FIELD_GET(E830_VSIQF_FD_CNT_FD_BCNT_M, fd_size);
1556 fd_cnt_g = FIELD_GET(E830_VSIQF_FD_CNT_FD_GCNT_M, fd_cnt);
1557 fd_cnt_b = FIELD_GET(E830_VSIQF_FD_CNT_FD_BCNT_M, fd_cnt);
1558 break;
1559 case ICE_MAC_E810:
1560 default:
1561 fd_size_g = FIELD_GET(E800_VSIQF_FD_CNT_FD_GCNT_M, fd_size);
1562 fd_size_b = FIELD_GET(E800_VSIQF_FD_CNT_FD_BCNT_M, fd_size);
1563 fd_cnt_g = FIELD_GET(E800_VSIQF_FD_CNT_FD_GCNT_M, fd_cnt);
1564 fd_cnt_b = FIELD_GET(E800_VSIQF_FD_CNT_FD_BCNT_M, fd_cnt);
1565 }
1566
1567 dev_dbg(dev, "VF %d: Size in the FD table: guaranteed:0x%x, best effort:0x%x\n",
1568 vf->vf_id, fd_size_g, fd_size_b);
1569 dev_dbg(dev, "VF %d: Filter counter in the FD table: guaranteed:0x%x, best effort:0x%x\n",
1570 vf->vf_id, fd_cnt_g, fd_cnt_b);
1571}
1572
1573/**
1574 * ice_vf_verify_rx_desc - verify received FDIR programming status descriptor
1575 * @vf: pointer to the VF info
1576 * @ctx: FDIR context info for post processing
1577 * @status: virtchnl FDIR program status
1578 *
1579 * Return: 0 on success, and other on error.
1580 */
1581static int
1582ice_vf_verify_rx_desc(struct ice_vf *vf, struct ice_vf_fdir_ctx *ctx,
1583 enum virtchnl_fdir_prgm_status *status)
1584{
1585 struct device *dev = ice_pf_to_dev(vf->pf);
1586 u32 stat_err, error, prog_id;
1587 int ret;
1588
1589 stat_err = le16_to_cpu(ctx->rx_desc.wb.status_error0);
1590 if (FIELD_GET(ICE_FXD_FLTR_WB_QW1_DD_M, stat_err) !=
1591 ICE_FXD_FLTR_WB_QW1_DD_YES) {
1592 *status = VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE;
1593 dev_err(dev, "VF %d: Desc Done not set\n", vf->vf_id);
1594 ret = -EINVAL;
1595 goto err_exit;
1596 }
1597
1598 prog_id = FIELD_GET(ICE_FXD_FLTR_WB_QW1_PROG_ID_M, stat_err);
1599 if (prog_id == ICE_FXD_FLTR_WB_QW1_PROG_ADD &&
1600 ctx->v_opcode != VIRTCHNL_OP_ADD_FDIR_FILTER) {
1601 dev_err(dev, "VF %d: Desc show add, but ctx not",
1602 vf->vf_id);
1603 *status = VIRTCHNL_FDIR_FAILURE_RULE_INVALID;
1604 ret = -EINVAL;
1605 goto err_exit;
1606 }
1607
1608 if (prog_id == ICE_FXD_FLTR_WB_QW1_PROG_DEL &&
1609 ctx->v_opcode != VIRTCHNL_OP_DEL_FDIR_FILTER) {
1610 dev_err(dev, "VF %d: Desc show del, but ctx not",
1611 vf->vf_id);
1612 *status = VIRTCHNL_FDIR_FAILURE_RULE_INVALID;
1613 ret = -EINVAL;
1614 goto err_exit;
1615 }
1616
1617 error = FIELD_GET(ICE_FXD_FLTR_WB_QW1_FAIL_M, stat_err);
1618 if (error == ICE_FXD_FLTR_WB_QW1_FAIL_YES) {
1619 if (prog_id == ICE_FXD_FLTR_WB_QW1_PROG_ADD) {
1620 dev_err(dev, "VF %d, Failed to add FDIR rule due to no space in the table",
1621 vf->vf_id);
1622 *status = VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE;
1623 } else {
1624 dev_err(dev, "VF %d, Failed to remove FDIR rule, attempt to remove non-existent entry",
1625 vf->vf_id);
1626 *status = VIRTCHNL_FDIR_FAILURE_RULE_NONEXIST;
1627 }
1628 ret = -EINVAL;
1629 goto err_exit;
1630 }
1631
1632 error = FIELD_GET(ICE_FXD_FLTR_WB_QW1_FAIL_PROF_M, stat_err);
1633 if (error == ICE_FXD_FLTR_WB_QW1_FAIL_PROF_YES) {
1634 dev_err(dev, "VF %d: Profile matching error", vf->vf_id);
1635 *status = VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE;
1636 ret = -EINVAL;
1637 goto err_exit;
1638 }
1639
1640 *status = VIRTCHNL_FDIR_SUCCESS;
1641
1642 return 0;
1643
1644err_exit:
1645 ice_vf_fdir_dump_info(vf);
1646 return ret;
1647}
1648
1649static int ice_fdir_is_tunnel(enum ice_fdir_tunnel_type ttype)
1650{
1651 return (ttype == ICE_FDIR_TUNNEL_TYPE_GRE_INNER ||
1652 ttype == ICE_FDIR_TUNNEL_TYPE_GTPU_INNER ||
1653 ttype == ICE_FDIR_TUNNEL_TYPE_GTPU_EH_INNER ||
1654 ttype == ICE_FDIR_TUNNEL_TYPE_GTPOGRE_INNER ||
1655 ttype == ICE_FDIR_TUNNEL_TYPE_ECPRI ||
1656 ttype == ICE_FDIR_TUNNEL_TYPE_L2TPV2_INNER);
1657}
1658
1659/**
1660 * ice_vc_add_fdir_fltr_post
1661 * @vf: pointer to the VF structure
1662 * @ctx: FDIR context info for post processing
1663 * @status: virtchnl FDIR program status
1664 * @success: true implies success, false implies failure
1665 *
1666 * Post process for flow director add command. If success, then do post process
1667 * and send back success msg by virtchnl. Otherwise, do context reversion and
1668 * send back failure msg by virtchnl.
1669 *
1670 * Return: 0 on success, and other on error.
1671 */
1672static int
1673ice_vc_add_fdir_fltr_post(struct ice_vf *vf, struct ice_vf_fdir_ctx *ctx,
1674 enum virtchnl_fdir_prgm_status status,
1675 bool success)
1676{
1677 struct virtchnl_fdir_fltr_conf *conf = ctx->conf;
1678 struct device *dev = ice_pf_to_dev(vf->pf);
1679 enum virtchnl_status_code v_ret;
1680 struct virtchnl_fdir_add *resp;
1681 int ret, len, is_tun;
1682
1683 v_ret = VIRTCHNL_STATUS_SUCCESS;
1684 len = sizeof(*resp);
1685 resp = kzalloc(len, GFP_KERNEL);
1686 if (!resp) {
1687 len = 0;
1688 v_ret = VIRTCHNL_STATUS_ERR_NO_MEMORY;
1689 dev_dbg(dev, "VF %d: Alloc resp buf fail", vf->vf_id);
1690 goto err_exit;
1691 }
1692
1693 if (!success)
1694 goto err_exit;
1695
1696 is_tun = 0;
1697 resp->status = status;
1698 resp->flow_id = conf->flow_id;
1699 vf->fdir.fdir_fltr_cnt[conf->input.flow_type][is_tun]++;
1700 vf->fdir.fdir_fltr_cnt_total++;
1701
1702 ret = ice_vc_send_msg_to_vf(vf, ctx->v_opcode, v_ret,
1703 (u8 *)resp, len);
1704 kfree(resp);
1705
1706 dev_dbg(dev, "VF %d: flow_id:0x%X, FDIR %s success!\n",
1707 vf->vf_id, conf->flow_id,
1708 (ctx->v_opcode == VIRTCHNL_OP_ADD_FDIR_FILTER) ?
1709 "add" : "del");
1710 return ret;
1711
1712err_exit:
1713 if (resp)
1714 resp->status = status;
1715 ice_vc_fdir_remove_entry(vf, conf, conf->flow_id);
1716 devm_kfree(dev, conf);
1717
1718 ret = ice_vc_send_msg_to_vf(vf, ctx->v_opcode, v_ret,
1719 (u8 *)resp, len);
1720 kfree(resp);
1721 return ret;
1722}
1723
1724/**
1725 * ice_vc_del_fdir_fltr_post
1726 * @vf: pointer to the VF structure
1727 * @ctx: FDIR context info for post processing
1728 * @status: virtchnl FDIR program status
1729 * @success: true implies success, false implies failure
1730 *
1731 * Post process for flow director del command. If success, then do post process
1732 * and send back success msg by virtchnl. Otherwise, do context reversion and
1733 * send back failure msg by virtchnl.
1734 *
1735 * Return: 0 on success, and other on error.
1736 */
1737static int
1738ice_vc_del_fdir_fltr_post(struct ice_vf *vf, struct ice_vf_fdir_ctx *ctx,
1739 enum virtchnl_fdir_prgm_status status,
1740 bool success)
1741{
1742 struct virtchnl_fdir_fltr_conf *conf = ctx->conf;
1743 struct device *dev = ice_pf_to_dev(vf->pf);
1744 enum virtchnl_status_code v_ret;
1745 struct virtchnl_fdir_del *resp;
1746 int ret, len, is_tun;
1747
1748 v_ret = VIRTCHNL_STATUS_SUCCESS;
1749 len = sizeof(*resp);
1750 resp = kzalloc(len, GFP_KERNEL);
1751 if (!resp) {
1752 len = 0;
1753 v_ret = VIRTCHNL_STATUS_ERR_NO_MEMORY;
1754 dev_dbg(dev, "VF %d: Alloc resp buf fail", vf->vf_id);
1755 goto err_exit;
1756 }
1757
1758 if (!success)
1759 goto err_exit;
1760
1761 is_tun = 0;
1762 resp->status = status;
1763 ice_vc_fdir_remove_entry(vf, conf, conf->flow_id);
1764 vf->fdir.fdir_fltr_cnt[conf->input.flow_type][is_tun]--;
1765 vf->fdir.fdir_fltr_cnt_total--;
1766
1767 ret = ice_vc_send_msg_to_vf(vf, ctx->v_opcode, v_ret,
1768 (u8 *)resp, len);
1769 kfree(resp);
1770
1771 dev_dbg(dev, "VF %d: flow_id:0x%X, FDIR %s success!\n",
1772 vf->vf_id, conf->flow_id,
1773 (ctx->v_opcode == VIRTCHNL_OP_ADD_FDIR_FILTER) ?
1774 "add" : "del");
1775 devm_kfree(dev, conf);
1776 return ret;
1777
1778err_exit:
1779 if (resp)
1780 resp->status = status;
1781 if (success)
1782 devm_kfree(dev, conf);
1783
1784 ret = ice_vc_send_msg_to_vf(vf, ctx->v_opcode, v_ret,
1785 (u8 *)resp, len);
1786 kfree(resp);
1787 return ret;
1788}
1789
1790/**
1791 * ice_flush_fdir_ctx
1792 * @pf: pointer to the PF structure
1793 *
1794 * Flush all the pending event on ctx_done list and process them.
1795 */
1796void ice_flush_fdir_ctx(struct ice_pf *pf)
1797{
1798 struct ice_vf *vf;
1799 unsigned int bkt;
1800
1801 if (!test_and_clear_bit(ICE_FD_VF_FLUSH_CTX, pf->state))
1802 return;
1803
1804 mutex_lock(&pf->vfs.table_lock);
1805 ice_for_each_vf(pf, bkt, vf) {
1806 struct device *dev = ice_pf_to_dev(pf);
1807 enum virtchnl_fdir_prgm_status status;
1808 struct ice_vf_fdir_ctx *ctx;
1809 unsigned long flags;
1810 int ret;
1811
1812 if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states))
1813 continue;
1814
1815 if (vf->ctrl_vsi_idx == ICE_NO_VSI)
1816 continue;
1817
1818 ctx = &vf->fdir.ctx_done;
1819 spin_lock_irqsave(&vf->fdir.ctx_lock, flags);
1820 if (!(ctx->flags & ICE_VF_FDIR_CTX_VALID)) {
1821 spin_unlock_irqrestore(&vf->fdir.ctx_lock, flags);
1822 continue;
1823 }
1824 spin_unlock_irqrestore(&vf->fdir.ctx_lock, flags);
1825
1826 WARN_ON(ctx->stat == ICE_FDIR_CTX_READY);
1827 if (ctx->stat == ICE_FDIR_CTX_TIMEOUT) {
1828 status = VIRTCHNL_FDIR_FAILURE_RULE_TIMEOUT;
1829 dev_err(dev, "VF %d: ctrl_vsi irq timeout\n",
1830 vf->vf_id);
1831 goto err_exit;
1832 }
1833
1834 ret = ice_vf_verify_rx_desc(vf, ctx, &status);
1835 if (ret)
1836 goto err_exit;
1837
1838 if (ctx->v_opcode == VIRTCHNL_OP_ADD_FDIR_FILTER)
1839 ice_vc_add_fdir_fltr_post(vf, ctx, status, true);
1840 else if (ctx->v_opcode == VIRTCHNL_OP_DEL_FDIR_FILTER)
1841 ice_vc_del_fdir_fltr_post(vf, ctx, status, true);
1842 else
1843 dev_err(dev, "VF %d: Unsupported opcode\n", vf->vf_id);
1844
1845 spin_lock_irqsave(&vf->fdir.ctx_lock, flags);
1846 ctx->flags &= ~ICE_VF_FDIR_CTX_VALID;
1847 spin_unlock_irqrestore(&vf->fdir.ctx_lock, flags);
1848 continue;
1849err_exit:
1850 if (ctx->v_opcode == VIRTCHNL_OP_ADD_FDIR_FILTER)
1851 ice_vc_add_fdir_fltr_post(vf, ctx, status, false);
1852 else if (ctx->v_opcode == VIRTCHNL_OP_DEL_FDIR_FILTER)
1853 ice_vc_del_fdir_fltr_post(vf, ctx, status, false);
1854 else
1855 dev_err(dev, "VF %d: Unsupported opcode\n", vf->vf_id);
1856
1857 spin_lock_irqsave(&vf->fdir.ctx_lock, flags);
1858 ctx->flags &= ~ICE_VF_FDIR_CTX_VALID;
1859 spin_unlock_irqrestore(&vf->fdir.ctx_lock, flags);
1860 }
1861 mutex_unlock(&pf->vfs.table_lock);
1862}
1863
1864/**
1865 * ice_vc_fdir_set_irq_ctx - set FDIR context info for later IRQ handler
1866 * @vf: pointer to the VF structure
1867 * @conf: FDIR configuration for each filter
1868 * @v_opcode: virtual channel operation code
1869 *
1870 * Return: 0 on success, and other on error.
1871 */
1872static int
1873ice_vc_fdir_set_irq_ctx(struct ice_vf *vf, struct virtchnl_fdir_fltr_conf *conf,
1874 enum virtchnl_ops v_opcode)
1875{
1876 struct device *dev = ice_pf_to_dev(vf->pf);
1877 struct ice_vf_fdir_ctx *ctx;
1878 unsigned long flags;
1879
1880 ctx = &vf->fdir.ctx_irq;
1881 spin_lock_irqsave(&vf->fdir.ctx_lock, flags);
1882 if ((vf->fdir.ctx_irq.flags & ICE_VF_FDIR_CTX_VALID) ||
1883 (vf->fdir.ctx_done.flags & ICE_VF_FDIR_CTX_VALID)) {
1884 spin_unlock_irqrestore(&vf->fdir.ctx_lock, flags);
1885 dev_dbg(dev, "VF %d: Last request is still in progress\n",
1886 vf->vf_id);
1887 return -EBUSY;
1888 }
1889 ctx->flags |= ICE_VF_FDIR_CTX_VALID;
1890 spin_unlock_irqrestore(&vf->fdir.ctx_lock, flags);
1891
1892 ctx->conf = conf;
1893 ctx->v_opcode = v_opcode;
1894 ctx->stat = ICE_FDIR_CTX_READY;
1895 timer_setup(&ctx->rx_tmr, ice_vf_fdir_timer, 0);
1896
1897 mod_timer(&ctx->rx_tmr, round_jiffies(msecs_to_jiffies(10) + jiffies));
1898
1899 return 0;
1900}
1901
1902/**
1903 * ice_vc_fdir_clear_irq_ctx - clear FDIR context info for IRQ handler
1904 * @vf: pointer to the VF structure
1905 *
1906 * Return: 0 on success, and other on error.
1907 */
1908static void ice_vc_fdir_clear_irq_ctx(struct ice_vf *vf)
1909{
1910 struct ice_vf_fdir_ctx *ctx = &vf->fdir.ctx_irq;
1911 unsigned long flags;
1912
1913 del_timer(&ctx->rx_tmr);
1914 spin_lock_irqsave(&vf->fdir.ctx_lock, flags);
1915 ctx->flags &= ~ICE_VF_FDIR_CTX_VALID;
1916 spin_unlock_irqrestore(&vf->fdir.ctx_lock, flags);
1917}
1918
1919/**
1920 * ice_vc_parser_fv_check_diff - check two parsed FDIR profile fv context
1921 * @fv_a: struct of parsed FDIR profile field vector
1922 * @fv_b: struct of parsed FDIR profile field vector
1923 *
1924 * Check if the two parsed FDIR profile field vector context are different,
1925 * including proto_id, offset and mask.
1926 *
1927 * Return: true on different, false on otherwise.
1928 */
1929static bool ice_vc_parser_fv_check_diff(struct ice_parser_fv *fv_a,
1930 struct ice_parser_fv *fv_b)
1931{
1932 return (fv_a->proto_id != fv_b->proto_id ||
1933 fv_a->offset != fv_b->offset ||
1934 fv_a->msk != fv_b->msk);
1935}
1936
1937/**
1938 * ice_vc_parser_fv_save - save parsed FDIR profile fv context
1939 * @fv: struct of parsed FDIR profile field vector
1940 * @fv_src: parsed FDIR profile field vector context to save
1941 *
1942 * Save the parsed FDIR profile field vector context, including proto_id,
1943 * offset and mask.
1944 *
1945 * Return: Void.
1946 */
1947static void ice_vc_parser_fv_save(struct ice_parser_fv *fv,
1948 struct ice_parser_fv *fv_src)
1949{
1950 fv->proto_id = fv_src->proto_id;
1951 fv->offset = fv_src->offset;
1952 fv->msk = fv_src->msk;
1953 fv->spec = 0;
1954}
1955
1956/**
1957 * ice_vc_add_fdir_raw - add a raw FDIR filter for VF
1958 * @vf: pointer to the VF info
1959 * @conf: FDIR configuration for each filter
1960 * @v_ret: the final VIRTCHNL code
1961 * @stat: pointer to the VIRTCHNL_OP_ADD_FDIR_FILTER
1962 * @len: length of the stat
1963 *
1964 * Return: 0 on success or negative errno on failure.
1965 */
1966static int
1967ice_vc_add_fdir_raw(struct ice_vf *vf,
1968 struct virtchnl_fdir_fltr_conf *conf,
1969 enum virtchnl_status_code *v_ret,
1970 struct virtchnl_fdir_add *stat, int len)
1971{
1972 struct ice_vsi *vf_vsi, *ctrl_vsi;
1973 struct ice_fdir_prof_info *pi;
1974 struct ice_pf *pf = vf->pf;
1975 int ret, ptg, id, i;
1976 struct device *dev;
1977 struct ice_hw *hw;
1978 bool fv_found;
1979
1980 dev = ice_pf_to_dev(pf);
1981 hw = &pf->hw;
1982 *v_ret = VIRTCHNL_STATUS_ERR_PARAM;
1983 stat->status = VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE;
1984
1985 id = find_first_bit(conf->prof->ptypes, ICE_FLOW_PTYPE_MAX);
1986 ptg = hw->blk[ICE_BLK_FD].xlt1.t[id];
1987
1988 vf_vsi = ice_get_vf_vsi(vf);
1989 if (!vf_vsi) {
1990 dev_err(dev, "Can not get FDIR vf_vsi for VF %d\n", vf->vf_id);
1991 return -ENODEV;
1992 }
1993
1994 ctrl_vsi = pf->vsi[vf->ctrl_vsi_idx];
1995 if (!ctrl_vsi) {
1996 dev_err(dev, "Can not get FDIR ctrl_vsi for VF %d\n",
1997 vf->vf_id);
1998 return -ENODEV;
1999 }
2000
2001 fv_found = false;
2002
2003 /* Check if profile info already exists, then update the counter */
2004 pi = &vf->fdir_prof_info[ptg];
2005 if (pi->fdir_active_cnt != 0) {
2006 for (i = 0; i < ICE_MAX_FV_WORDS; i++)
2007 if (ice_vc_parser_fv_check_diff(&pi->prof.fv[i],
2008 &conf->prof->fv[i]))
2009 break;
2010 if (i == ICE_MAX_FV_WORDS) {
2011 fv_found = true;
2012 pi->fdir_active_cnt++;
2013 }
2014 }
2015
2016 /* HW profile setting is only required for the first time */
2017 if (!fv_found) {
2018 ret = ice_flow_set_parser_prof(hw, vf_vsi->idx,
2019 ctrl_vsi->idx, conf->prof,
2020 ICE_BLK_FD);
2021
2022 if (ret) {
2023 *v_ret = VIRTCHNL_STATUS_ERR_NO_MEMORY;
2024 dev_dbg(dev, "VF %d: insert hw prof failed\n",
2025 vf->vf_id);
2026 return ret;
2027 }
2028 }
2029
2030 ret = ice_vc_fdir_insert_entry(vf, conf, &conf->flow_id);
2031 if (ret) {
2032 *v_ret = VIRTCHNL_STATUS_ERR_NO_MEMORY;
2033 dev_dbg(dev, "VF %d: insert FDIR list failed\n",
2034 vf->vf_id);
2035 return ret;
2036 }
2037
2038 ret = ice_vc_fdir_set_irq_ctx(vf, conf,
2039 VIRTCHNL_OP_ADD_FDIR_FILTER);
2040 if (ret) {
2041 dev_dbg(dev, "VF %d: set FDIR context failed\n",
2042 vf->vf_id);
2043 goto err_rem_entry;
2044 }
2045
2046 ret = ice_vc_fdir_write_fltr(vf, conf, true, false);
2047 if (ret) {
2048 dev_err(dev, "VF %d: adding FDIR raw flow rule failed, ret:%d\n",
2049 vf->vf_id, ret);
2050 goto err_clr_irq;
2051 }
2052
2053 /* Save parsed profile fv info of the FDIR rule for the first time */
2054 if (!fv_found) {
2055 for (i = 0; i < conf->prof->fv_num; i++)
2056 ice_vc_parser_fv_save(&pi->prof.fv[i],
2057 &conf->prof->fv[i]);
2058 pi->prof.fv_num = conf->prof->fv_num;
2059 pi->fdir_active_cnt = 1;
2060 }
2061
2062 return 0;
2063
2064err_clr_irq:
2065 ice_vc_fdir_clear_irq_ctx(vf);
2066err_rem_entry:
2067 ice_vc_fdir_remove_entry(vf, conf, conf->flow_id);
2068 return ret;
2069}
2070
2071/**
2072 * ice_vc_add_fdir_fltr - add a FDIR filter for VF by the msg buffer
2073 * @vf: pointer to the VF info
2074 * @msg: pointer to the msg buffer
2075 *
2076 * Return: 0 on success, and other on error.
2077 */
2078int ice_vc_add_fdir_fltr(struct ice_vf *vf, u8 *msg)
2079{
2080 struct virtchnl_fdir_add *fltr = (struct virtchnl_fdir_add *)msg;
2081 struct virtchnl_fdir_add *stat = NULL;
2082 struct virtchnl_fdir_fltr_conf *conf;
2083 enum virtchnl_status_code v_ret;
2084 struct ice_vsi *vf_vsi;
2085 struct device *dev;
2086 struct ice_pf *pf;
2087 int is_tun = 0;
2088 int len = 0;
2089 int ret;
2090
2091 pf = vf->pf;
2092 dev = ice_pf_to_dev(pf);
2093 vf_vsi = ice_get_vf_vsi(vf);
2094
2095#define ICE_VF_MAX_FDIR_FILTERS 128
2096 if (!ice_fdir_num_avail_fltr(&pf->hw, vf_vsi) ||
2097 vf->fdir.fdir_fltr_cnt_total >= ICE_VF_MAX_FDIR_FILTERS) {
2098 v_ret = VIRTCHNL_STATUS_ERR_PARAM;
2099 dev_err(dev, "Max number of FDIR filters for VF %d is reached\n",
2100 vf->vf_id);
2101 goto err_exit;
2102 }
2103
2104 ret = ice_vc_fdir_param_check(vf, fltr->vsi_id);
2105 if (ret) {
2106 v_ret = VIRTCHNL_STATUS_ERR_PARAM;
2107 dev_dbg(dev, "Parameter check for VF %d failed\n", vf->vf_id);
2108 goto err_exit;
2109 }
2110
2111 ret = ice_vf_start_ctrl_vsi(vf);
2112 if (ret && (ret != -EEXIST)) {
2113 v_ret = VIRTCHNL_STATUS_ERR_PARAM;
2114 dev_err(dev, "Init FDIR for VF %d failed, ret:%d\n",
2115 vf->vf_id, ret);
2116 goto err_exit;
2117 }
2118
2119 stat = kzalloc(sizeof(*stat), GFP_KERNEL);
2120 if (!stat) {
2121 v_ret = VIRTCHNL_STATUS_ERR_NO_MEMORY;
2122 dev_dbg(dev, "Alloc stat for VF %d failed\n", vf->vf_id);
2123 goto err_exit;
2124 }
2125
2126 conf = devm_kzalloc(dev, sizeof(*conf), GFP_KERNEL);
2127 if (!conf) {
2128 v_ret = VIRTCHNL_STATUS_ERR_NO_MEMORY;
2129 dev_dbg(dev, "Alloc conf for VF %d failed\n", vf->vf_id);
2130 goto err_exit;
2131 }
2132
2133 len = sizeof(*stat);
2134 ret = ice_vc_validate_fdir_fltr(vf, fltr, conf);
2135 if (ret) {
2136 v_ret = VIRTCHNL_STATUS_ERR_PARAM;
2137 stat->status = VIRTCHNL_FDIR_FAILURE_RULE_INVALID;
2138 dev_dbg(dev, "Invalid FDIR filter from VF %d\n", vf->vf_id);
2139 goto err_free_conf;
2140 }
2141
2142 if (fltr->validate_only) {
2143 v_ret = VIRTCHNL_STATUS_SUCCESS;
2144 stat->status = VIRTCHNL_FDIR_SUCCESS;
2145 devm_kfree(dev, conf);
2146 ret = ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_ADD_FDIR_FILTER,
2147 v_ret, (u8 *)stat, len);
2148 goto exit;
2149 }
2150
2151 /* For raw FDIR filters created by the parser */
2152 if (conf->parser_ena) {
2153 ret = ice_vc_add_fdir_raw(vf, conf, &v_ret, stat, len);
2154 if (ret)
2155 goto err_free_conf;
2156 goto exit;
2157 }
2158
2159 is_tun = ice_fdir_is_tunnel(conf->ttype);
2160 ret = ice_vc_fdir_config_input_set(vf, fltr, conf, is_tun);
2161 if (ret) {
2162 v_ret = VIRTCHNL_STATUS_SUCCESS;
2163 stat->status = VIRTCHNL_FDIR_FAILURE_RULE_CONFLICT;
2164 dev_err(dev, "VF %d: FDIR input set configure failed, ret:%d\n",
2165 vf->vf_id, ret);
2166 goto err_free_conf;
2167 }
2168
2169 ret = ice_vc_fdir_is_dup_fltr(vf, conf);
2170 if (ret) {
2171 v_ret = VIRTCHNL_STATUS_SUCCESS;
2172 stat->status = VIRTCHNL_FDIR_FAILURE_RULE_EXIST;
2173 dev_dbg(dev, "VF %d: duplicated FDIR rule detected\n",
2174 vf->vf_id);
2175 goto err_free_conf;
2176 }
2177
2178 ret = ice_vc_fdir_insert_entry(vf, conf, &conf->flow_id);
2179 if (ret) {
2180 v_ret = VIRTCHNL_STATUS_SUCCESS;
2181 stat->status = VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE;
2182 dev_dbg(dev, "VF %d: insert FDIR list failed\n", vf->vf_id);
2183 goto err_free_conf;
2184 }
2185
2186 ret = ice_vc_fdir_set_irq_ctx(vf, conf, VIRTCHNL_OP_ADD_FDIR_FILTER);
2187 if (ret) {
2188 v_ret = VIRTCHNL_STATUS_SUCCESS;
2189 stat->status = VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE;
2190 dev_dbg(dev, "VF %d: set FDIR context failed\n", vf->vf_id);
2191 goto err_rem_entry;
2192 }
2193
2194 ret = ice_vc_fdir_write_fltr(vf, conf, true, is_tun);
2195 if (ret) {
2196 v_ret = VIRTCHNL_STATUS_SUCCESS;
2197 stat->status = VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE;
2198 dev_err(dev, "VF %d: writing FDIR rule failed, ret:%d\n",
2199 vf->vf_id, ret);
2200 goto err_clr_irq;
2201 }
2202
2203exit:
2204 kfree(stat);
2205 return ret;
2206
2207err_clr_irq:
2208 ice_vc_fdir_clear_irq_ctx(vf);
2209err_rem_entry:
2210 ice_vc_fdir_remove_entry(vf, conf, conf->flow_id);
2211err_free_conf:
2212 devm_kfree(dev, conf);
2213err_exit:
2214 ret = ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_ADD_FDIR_FILTER, v_ret,
2215 (u8 *)stat, len);
2216 kfree(stat);
2217 return ret;
2218}
2219
2220/**
2221 * ice_vc_del_fdir_raw - delete a raw FDIR filter for VF
2222 * @vf: pointer to the VF info
2223 * @conf: FDIR configuration for each filter
2224 * @v_ret: the final VIRTCHNL code
2225 * @stat: pointer to the VIRTCHNL_OP_DEL_FDIR_FILTER
2226 * @len: length of the stat
2227 *
2228 * Return: 0 on success or negative errno on failure.
2229 */
2230static int
2231ice_vc_del_fdir_raw(struct ice_vf *vf,
2232 struct virtchnl_fdir_fltr_conf *conf,
2233 enum virtchnl_status_code *v_ret,
2234 struct virtchnl_fdir_del *stat, int len)
2235{
2236 struct ice_vsi *vf_vsi, *ctrl_vsi;
2237 enum ice_block blk = ICE_BLK_FD;
2238 struct ice_fdir_prof_info *pi;
2239 struct ice_pf *pf = vf->pf;
2240 struct device *dev;
2241 struct ice_hw *hw;
2242 unsigned long id;
2243 u16 vsi_num;
2244 int ptg;
2245 int ret;
2246
2247 dev = ice_pf_to_dev(pf);
2248 hw = &pf->hw;
2249 *v_ret = VIRTCHNL_STATUS_ERR_PARAM;
2250 stat->status = VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE;
2251
2252 id = find_first_bit(conf->prof->ptypes, ICE_FLOW_PTYPE_MAX);
2253 ptg = hw->blk[ICE_BLK_FD].xlt1.t[id];
2254
2255 ret = ice_vc_fdir_write_fltr(vf, conf, false, false);
2256 if (ret) {
2257 dev_err(dev, "VF %u: deleting FDIR raw flow rule failed: %d\n",
2258 vf->vf_id, ret);
2259 return ret;
2260 }
2261
2262 vf_vsi = ice_get_vf_vsi(vf);
2263 if (!vf_vsi) {
2264 dev_err(dev, "Can not get FDIR vf_vsi for VF %u\n", vf->vf_id);
2265 return -ENODEV;
2266 }
2267
2268 ctrl_vsi = pf->vsi[vf->ctrl_vsi_idx];
2269 if (!ctrl_vsi) {
2270 dev_err(dev, "Can not get FDIR ctrl_vsi for VF %u\n",
2271 vf->vf_id);
2272 return -ENODEV;
2273 }
2274
2275 pi = &vf->fdir_prof_info[ptg];
2276 if (pi->fdir_active_cnt != 0) {
2277 pi->fdir_active_cnt--;
2278 /* Remove the profile id flow if no active FDIR rule left */
2279 if (!pi->fdir_active_cnt) {
2280 vsi_num = ice_get_hw_vsi_num(hw, ctrl_vsi->idx);
2281 ice_rem_prof_id_flow(hw, blk, vsi_num, id);
2282
2283 vsi_num = ice_get_hw_vsi_num(hw, vf_vsi->idx);
2284 ice_rem_prof_id_flow(hw, blk, vsi_num, id);
2285 }
2286 }
2287
2288 conf->parser_ena = false;
2289 return 0;
2290}
2291
2292/**
2293 * ice_vc_del_fdir_fltr - delete a FDIR filter for VF by the msg buffer
2294 * @vf: pointer to the VF info
2295 * @msg: pointer to the msg buffer
2296 *
2297 * Return: 0 on success, and other on error.
2298 */
2299int ice_vc_del_fdir_fltr(struct ice_vf *vf, u8 *msg)
2300{
2301 struct virtchnl_fdir_del *fltr = (struct virtchnl_fdir_del *)msg;
2302 struct virtchnl_fdir_del *stat = NULL;
2303 struct virtchnl_fdir_fltr_conf *conf;
2304 struct ice_vf_fdir *fdir = &vf->fdir;
2305 enum virtchnl_status_code v_ret;
2306 struct ice_fdir_fltr *input;
2307 enum ice_fltr_ptype flow;
2308 struct device *dev;
2309 struct ice_pf *pf;
2310 int is_tun = 0;
2311 int len = 0;
2312 int ret;
2313
2314 pf = vf->pf;
2315 dev = ice_pf_to_dev(pf);
2316 ret = ice_vc_fdir_param_check(vf, fltr->vsi_id);
2317 if (ret) {
2318 v_ret = VIRTCHNL_STATUS_ERR_PARAM;
2319 dev_dbg(dev, "Parameter check for VF %d failed\n", vf->vf_id);
2320 goto err_exit;
2321 }
2322
2323 stat = kzalloc(sizeof(*stat), GFP_KERNEL);
2324 if (!stat) {
2325 v_ret = VIRTCHNL_STATUS_ERR_NO_MEMORY;
2326 dev_dbg(dev, "Alloc stat for VF %d failed\n", vf->vf_id);
2327 goto err_exit;
2328 }
2329
2330 len = sizeof(*stat);
2331
2332 conf = ice_vc_fdir_lookup_entry(vf, fltr->flow_id);
2333 if (!conf) {
2334 v_ret = VIRTCHNL_STATUS_SUCCESS;
2335 stat->status = VIRTCHNL_FDIR_FAILURE_RULE_NONEXIST;
2336 dev_dbg(dev, "VF %d: FDIR invalid flow_id:0x%X\n",
2337 vf->vf_id, fltr->flow_id);
2338 goto err_exit;
2339 }
2340
2341 /* Just return failure when ctrl_vsi idx is invalid */
2342 if (vf->ctrl_vsi_idx == ICE_NO_VSI) {
2343 v_ret = VIRTCHNL_STATUS_SUCCESS;
2344 stat->status = VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE;
2345 dev_err(dev, "Invalid FDIR ctrl_vsi for VF %d\n", vf->vf_id);
2346 goto err_exit;
2347 }
2348
2349 ret = ice_vc_fdir_set_irq_ctx(vf, conf, VIRTCHNL_OP_DEL_FDIR_FILTER);
2350 if (ret) {
2351 v_ret = VIRTCHNL_STATUS_SUCCESS;
2352 stat->status = VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE;
2353 dev_dbg(dev, "VF %d: set FDIR context failed\n", vf->vf_id);
2354 goto err_exit;
2355 }
2356
2357 /* For raw FDIR filters created by the parser */
2358 if (conf->parser_ena) {
2359 ret = ice_vc_del_fdir_raw(vf, conf, &v_ret, stat, len);
2360 if (ret)
2361 goto err_del_tmr;
2362 goto exit;
2363 }
2364
2365 is_tun = ice_fdir_is_tunnel(conf->ttype);
2366 ret = ice_vc_fdir_write_fltr(vf, conf, false, is_tun);
2367 if (ret) {
2368 v_ret = VIRTCHNL_STATUS_SUCCESS;
2369 stat->status = VIRTCHNL_FDIR_FAILURE_RULE_NORESOURCE;
2370 dev_err(dev, "VF %d: writing FDIR rule failed, ret:%d\n",
2371 vf->vf_id, ret);
2372 goto err_del_tmr;
2373 }
2374
2375 /* Remove unused profiles to avoid unexpected behaviors */
2376 input = &conf->input;
2377 flow = input->flow_type;
2378 if (fdir->fdir_fltr_cnt[flow][is_tun] == 1)
2379 ice_vc_fdir_rem_prof(vf, flow, is_tun);
2380
2381exit:
2382 kfree(stat);
2383
2384 return ret;
2385
2386err_del_tmr:
2387 ice_vc_fdir_clear_irq_ctx(vf);
2388err_exit:
2389 ret = ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_DEL_FDIR_FILTER, v_ret,
2390 (u8 *)stat, len);
2391 kfree(stat);
2392 return ret;
2393}
2394
2395/**
2396 * ice_vf_fdir_init - init FDIR resource for VF
2397 * @vf: pointer to the VF info
2398 */
2399void ice_vf_fdir_init(struct ice_vf *vf)
2400{
2401 struct ice_vf_fdir *fdir = &vf->fdir;
2402
2403 idr_init(&fdir->fdir_rule_idr);
2404 INIT_LIST_HEAD(&fdir->fdir_rule_list);
2405
2406 spin_lock_init(&fdir->ctx_lock);
2407 fdir->ctx_irq.flags = 0;
2408 fdir->ctx_done.flags = 0;
2409 ice_vc_fdir_reset_cnt_all(fdir);
2410}
2411
2412/**
2413 * ice_vf_fdir_exit - destroy FDIR resource for VF
2414 * @vf: pointer to the VF info
2415 */
2416void ice_vf_fdir_exit(struct ice_vf *vf)
2417{
2418 ice_vc_fdir_flush_entry(vf);
2419 idr_destroy(&vf->fdir.fdir_rule_idr);
2420 ice_vc_fdir_rem_prof_all(vf);
2421 ice_vc_fdir_free_prof_all(vf);
2422}