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