24e1c6587772359943b28c26209db542cac8cdb6
[dpdk.git] / drivers / net / i40e / i40e_flow.c
1 /*-
2  *   BSD LICENSE
3  *
4  *   Copyright (c) 2016-2017 Intel Corporation. All rights reserved.
5  *
6  *   Redistribution and use in source and binary forms, with or without
7  *   modification, are permitted provided that the following conditions
8  *   are met:
9  *
10  *     * Redistributions of source code must retain the above copyright
11  *       notice, this list of conditions and the following disclaimer.
12  *     * Redistributions in binary form must reproduce the above copyright
13  *       notice, this list of conditions and the following disclaimer in
14  *       the documentation and/or other materials provided with the
15  *       distribution.
16  *     * Neither the name of Intel Corporation nor the names of its
17  *       contributors may be used to endorse or promote products derived
18  *       from this software without specific prior written permission.
19  *
20  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32
33 #include <sys/queue.h>
34 #include <stdio.h>
35 #include <errno.h>
36 #include <stdint.h>
37 #include <string.h>
38 #include <unistd.h>
39 #include <stdarg.h>
40
41 #include <rte_ether.h>
42 #include <rte_ethdev.h>
43 #include <rte_log.h>
44 #include <rte_memzone.h>
45 #include <rte_malloc.h>
46 #include <rte_eth_ctrl.h>
47 #include <rte_tailq.h>
48 #include <rte_flow_driver.h>
49
50 #include "i40e_logs.h"
51 #include "base/i40e_type.h"
52 #include "base/i40e_prototype.h"
53 #include "i40e_ethdev.h"
54
55 #define I40E_IPV4_TC_SHIFT      4
56 #define I40E_IPV6_TC_MASK       (0x00FF << I40E_IPV4_TC_SHIFT)
57 #define I40E_IPV6_FRAG_HEADER   44
58 #define I40E_TENANT_ARRAY_NUM   3
59 #define I40E_TCI_MASK           0xFFFF
60
61 static int i40e_flow_validate(struct rte_eth_dev *dev,
62                               const struct rte_flow_attr *attr,
63                               const struct rte_flow_item pattern[],
64                               const struct rte_flow_action actions[],
65                               struct rte_flow_error *error);
66 static struct rte_flow *i40e_flow_create(struct rte_eth_dev *dev,
67                                          const struct rte_flow_attr *attr,
68                                          const struct rte_flow_item pattern[],
69                                          const struct rte_flow_action actions[],
70                                          struct rte_flow_error *error);
71 static int i40e_flow_destroy(struct rte_eth_dev *dev,
72                              struct rte_flow *flow,
73                              struct rte_flow_error *error);
74 static int i40e_flow_flush(struct rte_eth_dev *dev,
75                            struct rte_flow_error *error);
76 static int
77 i40e_flow_parse_ethertype_pattern(struct rte_eth_dev *dev,
78                                   const struct rte_flow_item *pattern,
79                                   struct rte_flow_error *error,
80                                   struct rte_eth_ethertype_filter *filter);
81 static int i40e_flow_parse_ethertype_action(struct rte_eth_dev *dev,
82                                     const struct rte_flow_action *actions,
83                                     struct rte_flow_error *error,
84                                     struct rte_eth_ethertype_filter *filter);
85 static int i40e_flow_parse_fdir_pattern(struct rte_eth_dev *dev,
86                                         const struct rte_flow_item *pattern,
87                                         struct rte_flow_error *error,
88                                         struct rte_eth_fdir_filter *filter);
89 static int i40e_flow_parse_fdir_action(struct rte_eth_dev *dev,
90                                        const struct rte_flow_action *actions,
91                                        struct rte_flow_error *error,
92                                        struct rte_eth_fdir_filter *filter);
93 static int i40e_flow_parse_tunnel_action(struct rte_eth_dev *dev,
94                                  const struct rte_flow_action *actions,
95                                  struct rte_flow_error *error,
96                                  struct i40e_tunnel_filter_conf *filter);
97 static int i40e_flow_parse_attr(const struct rte_flow_attr *attr,
98                                 struct rte_flow_error *error);
99 static int i40e_flow_parse_ethertype_filter(struct rte_eth_dev *dev,
100                                     const struct rte_flow_attr *attr,
101                                     const struct rte_flow_item pattern[],
102                                     const struct rte_flow_action actions[],
103                                     struct rte_flow_error *error,
104                                     union i40e_filter_t *filter);
105 static int i40e_flow_parse_fdir_filter(struct rte_eth_dev *dev,
106                                        const struct rte_flow_attr *attr,
107                                        const struct rte_flow_item pattern[],
108                                        const struct rte_flow_action actions[],
109                                        struct rte_flow_error *error,
110                                        union i40e_filter_t *filter);
111 static int i40e_flow_parse_vxlan_filter(struct rte_eth_dev *dev,
112                                         const struct rte_flow_attr *attr,
113                                         const struct rte_flow_item pattern[],
114                                         const struct rte_flow_action actions[],
115                                         struct rte_flow_error *error,
116                                         union i40e_filter_t *filter);
117 static int i40e_flow_parse_mpls_filter(struct rte_eth_dev *dev,
118                                        const struct rte_flow_attr *attr,
119                                        const struct rte_flow_item pattern[],
120                                        const struct rte_flow_action actions[],
121                                        struct rte_flow_error *error,
122                                        union i40e_filter_t *filter);
123 static int i40e_flow_destroy_ethertype_filter(struct i40e_pf *pf,
124                                       struct i40e_ethertype_filter *filter);
125 static int i40e_flow_destroy_tunnel_filter(struct i40e_pf *pf,
126                                            struct i40e_tunnel_filter *filter);
127 static int i40e_flow_flush_fdir_filter(struct i40e_pf *pf);
128 static int i40e_flow_flush_ethertype_filter(struct i40e_pf *pf);
129 static int i40e_flow_flush_tunnel_filter(struct i40e_pf *pf);
130 static int
131 i40e_flow_parse_qinq_filter(struct rte_eth_dev *dev,
132                               const struct rte_flow_attr *attr,
133                               const struct rte_flow_item pattern[],
134                               const struct rte_flow_action actions[],
135                               struct rte_flow_error *error,
136                               union i40e_filter_t *filter);
137 static int
138 i40e_flow_parse_qinq_pattern(__rte_unused struct rte_eth_dev *dev,
139                               const struct rte_flow_item *pattern,
140                               struct rte_flow_error *error,
141                               struct i40e_tunnel_filter_conf *filter);
142
143 const struct rte_flow_ops i40e_flow_ops = {
144         .validate = i40e_flow_validate,
145         .create = i40e_flow_create,
146         .destroy = i40e_flow_destroy,
147         .flush = i40e_flow_flush,
148 };
149
150 union i40e_filter_t cons_filter;
151 enum rte_filter_type cons_filter_type = RTE_ETH_FILTER_NONE;
152
153 /* Pattern matched ethertype filter */
154 static enum rte_flow_item_type pattern_ethertype[] = {
155         RTE_FLOW_ITEM_TYPE_ETH,
156         RTE_FLOW_ITEM_TYPE_END,
157 };
158
159 /* Pattern matched flow director filter */
160 static enum rte_flow_item_type pattern_fdir_ipv4[] = {
161         RTE_FLOW_ITEM_TYPE_IPV4,
162         RTE_FLOW_ITEM_TYPE_END,
163 };
164
165 static enum rte_flow_item_type pattern_fdir_ipv4_ext[] = {
166         RTE_FLOW_ITEM_TYPE_ETH,
167         RTE_FLOW_ITEM_TYPE_IPV4,
168         RTE_FLOW_ITEM_TYPE_END,
169 };
170
171 static enum rte_flow_item_type pattern_fdir_ipv4_udp[] = {
172         RTE_FLOW_ITEM_TYPE_IPV4,
173         RTE_FLOW_ITEM_TYPE_UDP,
174         RTE_FLOW_ITEM_TYPE_END,
175 };
176
177 static enum rte_flow_item_type pattern_fdir_ipv4_udp_ext[] = {
178         RTE_FLOW_ITEM_TYPE_ETH,
179         RTE_FLOW_ITEM_TYPE_IPV4,
180         RTE_FLOW_ITEM_TYPE_UDP,
181         RTE_FLOW_ITEM_TYPE_END,
182 };
183
184 static enum rte_flow_item_type pattern_fdir_ipv4_tcp[] = {
185         RTE_FLOW_ITEM_TYPE_IPV4,
186         RTE_FLOW_ITEM_TYPE_TCP,
187         RTE_FLOW_ITEM_TYPE_END,
188 };
189
190 static enum rte_flow_item_type pattern_fdir_ipv4_tcp_ext[] = {
191         RTE_FLOW_ITEM_TYPE_ETH,
192         RTE_FLOW_ITEM_TYPE_IPV4,
193         RTE_FLOW_ITEM_TYPE_TCP,
194         RTE_FLOW_ITEM_TYPE_END,
195 };
196
197 static enum rte_flow_item_type pattern_fdir_ipv4_sctp[] = {
198         RTE_FLOW_ITEM_TYPE_IPV4,
199         RTE_FLOW_ITEM_TYPE_SCTP,
200         RTE_FLOW_ITEM_TYPE_END,
201 };
202
203 static enum rte_flow_item_type pattern_fdir_ipv4_sctp_ext[] = {
204         RTE_FLOW_ITEM_TYPE_ETH,
205         RTE_FLOW_ITEM_TYPE_IPV4,
206         RTE_FLOW_ITEM_TYPE_SCTP,
207         RTE_FLOW_ITEM_TYPE_END,
208 };
209
210 static enum rte_flow_item_type pattern_fdir_ipv6[] = {
211         RTE_FLOW_ITEM_TYPE_IPV6,
212         RTE_FLOW_ITEM_TYPE_END,
213 };
214
215 static enum rte_flow_item_type pattern_fdir_ipv6_ext[] = {
216         RTE_FLOW_ITEM_TYPE_ETH,
217         RTE_FLOW_ITEM_TYPE_IPV6,
218         RTE_FLOW_ITEM_TYPE_END,
219 };
220
221 static enum rte_flow_item_type pattern_fdir_ipv6_udp[] = {
222         RTE_FLOW_ITEM_TYPE_IPV6,
223         RTE_FLOW_ITEM_TYPE_UDP,
224         RTE_FLOW_ITEM_TYPE_END,
225 };
226
227 static enum rte_flow_item_type pattern_fdir_ipv6_udp_ext[] = {
228         RTE_FLOW_ITEM_TYPE_ETH,
229         RTE_FLOW_ITEM_TYPE_IPV6,
230         RTE_FLOW_ITEM_TYPE_UDP,
231         RTE_FLOW_ITEM_TYPE_END,
232 };
233
234 static enum rte_flow_item_type pattern_fdir_ipv6_tcp[] = {
235         RTE_FLOW_ITEM_TYPE_IPV6,
236         RTE_FLOW_ITEM_TYPE_TCP,
237         RTE_FLOW_ITEM_TYPE_END,
238 };
239
240 static enum rte_flow_item_type pattern_fdir_ipv6_tcp_ext[] = {
241         RTE_FLOW_ITEM_TYPE_ETH,
242         RTE_FLOW_ITEM_TYPE_IPV6,
243         RTE_FLOW_ITEM_TYPE_TCP,
244         RTE_FLOW_ITEM_TYPE_END,
245 };
246
247 static enum rte_flow_item_type pattern_fdir_ipv6_sctp[] = {
248         RTE_FLOW_ITEM_TYPE_IPV6,
249         RTE_FLOW_ITEM_TYPE_SCTP,
250         RTE_FLOW_ITEM_TYPE_END,
251 };
252
253 static enum rte_flow_item_type pattern_fdir_ipv6_sctp_ext[] = {
254         RTE_FLOW_ITEM_TYPE_ETH,
255         RTE_FLOW_ITEM_TYPE_IPV6,
256         RTE_FLOW_ITEM_TYPE_SCTP,
257         RTE_FLOW_ITEM_TYPE_END,
258 };
259
260 /* Pattern matched tunnel filter */
261 static enum rte_flow_item_type pattern_vxlan_1[] = {
262         RTE_FLOW_ITEM_TYPE_ETH,
263         RTE_FLOW_ITEM_TYPE_IPV4,
264         RTE_FLOW_ITEM_TYPE_UDP,
265         RTE_FLOW_ITEM_TYPE_VXLAN,
266         RTE_FLOW_ITEM_TYPE_ETH,
267         RTE_FLOW_ITEM_TYPE_END,
268 };
269
270 static enum rte_flow_item_type pattern_vxlan_2[] = {
271         RTE_FLOW_ITEM_TYPE_ETH,
272         RTE_FLOW_ITEM_TYPE_IPV6,
273         RTE_FLOW_ITEM_TYPE_UDP,
274         RTE_FLOW_ITEM_TYPE_VXLAN,
275         RTE_FLOW_ITEM_TYPE_ETH,
276         RTE_FLOW_ITEM_TYPE_END,
277 };
278
279 static enum rte_flow_item_type pattern_vxlan_3[] = {
280         RTE_FLOW_ITEM_TYPE_ETH,
281         RTE_FLOW_ITEM_TYPE_IPV4,
282         RTE_FLOW_ITEM_TYPE_UDP,
283         RTE_FLOW_ITEM_TYPE_VXLAN,
284         RTE_FLOW_ITEM_TYPE_ETH,
285         RTE_FLOW_ITEM_TYPE_VLAN,
286         RTE_FLOW_ITEM_TYPE_END,
287 };
288
289 static enum rte_flow_item_type pattern_vxlan_4[] = {
290         RTE_FLOW_ITEM_TYPE_ETH,
291         RTE_FLOW_ITEM_TYPE_IPV6,
292         RTE_FLOW_ITEM_TYPE_UDP,
293         RTE_FLOW_ITEM_TYPE_VXLAN,
294         RTE_FLOW_ITEM_TYPE_ETH,
295         RTE_FLOW_ITEM_TYPE_VLAN,
296         RTE_FLOW_ITEM_TYPE_END,
297 };
298
299 /* Pattern matched MPLS */
300 static enum rte_flow_item_type pattern_mpls_1[] = {
301         RTE_FLOW_ITEM_TYPE_ETH,
302         RTE_FLOW_ITEM_TYPE_IPV4,
303         RTE_FLOW_ITEM_TYPE_UDP,
304         RTE_FLOW_ITEM_TYPE_MPLS,
305         RTE_FLOW_ITEM_TYPE_END,
306 };
307
308 static enum rte_flow_item_type pattern_mpls_2[] = {
309         RTE_FLOW_ITEM_TYPE_ETH,
310         RTE_FLOW_ITEM_TYPE_IPV6,
311         RTE_FLOW_ITEM_TYPE_UDP,
312         RTE_FLOW_ITEM_TYPE_MPLS,
313         RTE_FLOW_ITEM_TYPE_END,
314 };
315
316 static enum rte_flow_item_type pattern_mpls_3[] = {
317         RTE_FLOW_ITEM_TYPE_ETH,
318         RTE_FLOW_ITEM_TYPE_IPV4,
319         RTE_FLOW_ITEM_TYPE_GRE,
320         RTE_FLOW_ITEM_TYPE_MPLS,
321         RTE_FLOW_ITEM_TYPE_END,
322 };
323
324 static enum rte_flow_item_type pattern_mpls_4[] = {
325         RTE_FLOW_ITEM_TYPE_ETH,
326         RTE_FLOW_ITEM_TYPE_IPV6,
327         RTE_FLOW_ITEM_TYPE_GRE,
328         RTE_FLOW_ITEM_TYPE_MPLS,
329         RTE_FLOW_ITEM_TYPE_END,
330 };
331
332 /* Pattern matched QINQ */
333 static enum rte_flow_item_type pattern_qinq_1[] = {
334         RTE_FLOW_ITEM_TYPE_ETH,
335         RTE_FLOW_ITEM_TYPE_VLAN,
336         RTE_FLOW_ITEM_TYPE_VLAN,
337         RTE_FLOW_ITEM_TYPE_END,
338 };
339
340 static struct i40e_valid_pattern i40e_supported_patterns[] = {
341         /* Ethertype */
342         { pattern_ethertype, i40e_flow_parse_ethertype_filter },
343         /* FDIR */
344         { pattern_fdir_ipv4, i40e_flow_parse_fdir_filter },
345         { pattern_fdir_ipv4_ext, i40e_flow_parse_fdir_filter },
346         { pattern_fdir_ipv4_udp, i40e_flow_parse_fdir_filter },
347         { pattern_fdir_ipv4_udp_ext, i40e_flow_parse_fdir_filter },
348         { pattern_fdir_ipv4_tcp, i40e_flow_parse_fdir_filter },
349         { pattern_fdir_ipv4_tcp_ext, i40e_flow_parse_fdir_filter },
350         { pattern_fdir_ipv4_sctp, i40e_flow_parse_fdir_filter },
351         { pattern_fdir_ipv4_sctp_ext, i40e_flow_parse_fdir_filter },
352         { pattern_fdir_ipv6, i40e_flow_parse_fdir_filter },
353         { pattern_fdir_ipv6_ext, i40e_flow_parse_fdir_filter },
354         { pattern_fdir_ipv6_udp, i40e_flow_parse_fdir_filter },
355         { pattern_fdir_ipv6_udp_ext, i40e_flow_parse_fdir_filter },
356         { pattern_fdir_ipv6_tcp, i40e_flow_parse_fdir_filter },
357         { pattern_fdir_ipv6_tcp_ext, i40e_flow_parse_fdir_filter },
358         { pattern_fdir_ipv6_sctp, i40e_flow_parse_fdir_filter },
359         { pattern_fdir_ipv6_sctp_ext, i40e_flow_parse_fdir_filter },
360         /* VXLAN */
361         { pattern_vxlan_1, i40e_flow_parse_vxlan_filter },
362         { pattern_vxlan_2, i40e_flow_parse_vxlan_filter },
363         { pattern_vxlan_3, i40e_flow_parse_vxlan_filter },
364         { pattern_vxlan_4, i40e_flow_parse_vxlan_filter },
365         /* MPLSoUDP & MPLSoGRE */
366         { pattern_mpls_1, i40e_flow_parse_mpls_filter },
367         { pattern_mpls_2, i40e_flow_parse_mpls_filter },
368         { pattern_mpls_3, i40e_flow_parse_mpls_filter },
369         { pattern_mpls_4, i40e_flow_parse_mpls_filter },
370         /* QINQ */
371         { pattern_qinq_1, i40e_flow_parse_qinq_filter },
372 };
373
374 #define NEXT_ITEM_OF_ACTION(act, actions, index)                        \
375         do {                                                            \
376                 act = actions + index;                                  \
377                 while (act->type == RTE_FLOW_ACTION_TYPE_VOID) {        \
378                         index++;                                        \
379                         act = actions + index;                          \
380                 }                                                       \
381         } while (0)
382
383 /* Find the first VOID or non-VOID item pointer */
384 static const struct rte_flow_item *
385 i40e_find_first_item(const struct rte_flow_item *item, bool is_void)
386 {
387         bool is_find;
388
389         while (item->type != RTE_FLOW_ITEM_TYPE_END) {
390                 if (is_void)
391                         is_find = item->type == RTE_FLOW_ITEM_TYPE_VOID;
392                 else
393                         is_find = item->type != RTE_FLOW_ITEM_TYPE_VOID;
394                 if (is_find)
395                         break;
396                 item++;
397         }
398         return item;
399 }
400
401 /* Skip all VOID items of the pattern */
402 static void
403 i40e_pattern_skip_void_item(struct rte_flow_item *items,
404                             const struct rte_flow_item *pattern)
405 {
406         uint32_t cpy_count = 0;
407         const struct rte_flow_item *pb = pattern, *pe = pattern;
408
409         for (;;) {
410                 /* Find a non-void item first */
411                 pb = i40e_find_first_item(pb, false);
412                 if (pb->type == RTE_FLOW_ITEM_TYPE_END) {
413                         pe = pb;
414                         break;
415                 }
416
417                 /* Find a void item */
418                 pe = i40e_find_first_item(pb + 1, true);
419
420                 cpy_count = pe - pb;
421                 rte_memcpy(items, pb, sizeof(struct rte_flow_item) * cpy_count);
422
423                 items += cpy_count;
424
425                 if (pe->type == RTE_FLOW_ITEM_TYPE_END) {
426                         pb = pe;
427                         break;
428                 }
429
430                 pb = pe + 1;
431         }
432         /* Copy the END item. */
433         rte_memcpy(items, pe, sizeof(struct rte_flow_item));
434 }
435
436 /* Check if the pattern matches a supported item type array */
437 static bool
438 i40e_match_pattern(enum rte_flow_item_type *item_array,
439                    struct rte_flow_item *pattern)
440 {
441         struct rte_flow_item *item = pattern;
442
443         while ((*item_array == item->type) &&
444                (*item_array != RTE_FLOW_ITEM_TYPE_END)) {
445                 item_array++;
446                 item++;
447         }
448
449         return (*item_array == RTE_FLOW_ITEM_TYPE_END &&
450                 item->type == RTE_FLOW_ITEM_TYPE_END);
451 }
452
453 /* Find if there's parse filter function matched */
454 static parse_filter_t
455 i40e_find_parse_filter_func(struct rte_flow_item *pattern)
456 {
457         parse_filter_t parse_filter = NULL;
458         uint8_t i = 0;
459
460         for (; i < RTE_DIM(i40e_supported_patterns); i++) {
461                 if (i40e_match_pattern(i40e_supported_patterns[i].items,
462                                         pattern)) {
463                         parse_filter = i40e_supported_patterns[i].parse_filter;
464                         break;
465                 }
466         }
467
468         return parse_filter;
469 }
470
471 /* Parse attributes */
472 static int
473 i40e_flow_parse_attr(const struct rte_flow_attr *attr,
474                      struct rte_flow_error *error)
475 {
476         /* Must be input direction */
477         if (!attr->ingress) {
478                 rte_flow_error_set(error, EINVAL,
479                                    RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
480                                    attr, "Only support ingress.");
481                 return -rte_errno;
482         }
483
484         /* Not supported */
485         if (attr->egress) {
486                 rte_flow_error_set(error, EINVAL,
487                                    RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
488                                    attr, "Not support egress.");
489                 return -rte_errno;
490         }
491
492         /* Not supported */
493         if (attr->priority) {
494                 rte_flow_error_set(error, EINVAL,
495                                    RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
496                                    attr, "Not support priority.");
497                 return -rte_errno;
498         }
499
500         /* Not supported */
501         if (attr->group) {
502                 rte_flow_error_set(error, EINVAL,
503                                    RTE_FLOW_ERROR_TYPE_ATTR_GROUP,
504                                    attr, "Not support group.");
505                 return -rte_errno;
506         }
507
508         return 0;
509 }
510
511 static uint16_t
512 i40e_get_outer_vlan(struct rte_eth_dev *dev)
513 {
514         struct i40e_hw *hw = I40E_DEV_PRIVATE_TO_HW(dev->data->dev_private);
515         int qinq = dev->data->dev_conf.rxmode.hw_vlan_extend;
516         uint64_t reg_r = 0;
517         uint16_t reg_id;
518         uint16_t tpid;
519
520         if (qinq)
521                 reg_id = 2;
522         else
523                 reg_id = 3;
524
525         i40e_aq_debug_read_register(hw, I40E_GL_SWT_L2TAGCTRL(reg_id),
526                                     &reg_r, NULL);
527
528         tpid = (reg_r >> I40E_GL_SWT_L2TAGCTRL_ETHERTYPE_SHIFT) & 0xFFFF;
529
530         return tpid;
531 }
532
533 /* 1. Last in item should be NULL as range is not supported.
534  * 2. Supported filter types: MAC_ETHTYPE and ETHTYPE.
535  * 3. SRC mac_addr mask should be 00:00:00:00:00:00.
536  * 4. DST mac_addr mask should be 00:00:00:00:00:00 or
537  *    FF:FF:FF:FF:FF:FF
538  * 5. Ether_type mask should be 0xFFFF.
539  */
540 static int
541 i40e_flow_parse_ethertype_pattern(struct rte_eth_dev *dev,
542                                   const struct rte_flow_item *pattern,
543                                   struct rte_flow_error *error,
544                                   struct rte_eth_ethertype_filter *filter)
545 {
546         const struct rte_flow_item *item = pattern;
547         const struct rte_flow_item_eth *eth_spec;
548         const struct rte_flow_item_eth *eth_mask;
549         enum rte_flow_item_type item_type;
550         uint16_t outer_tpid;
551
552         outer_tpid = i40e_get_outer_vlan(dev);
553
554         for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
555                 if (item->last) {
556                         rte_flow_error_set(error, EINVAL,
557                                            RTE_FLOW_ERROR_TYPE_ITEM,
558                                            item,
559                                            "Not support range");
560                         return -rte_errno;
561                 }
562                 item_type = item->type;
563                 switch (item_type) {
564                 case RTE_FLOW_ITEM_TYPE_ETH:
565                         eth_spec = (const struct rte_flow_item_eth *)item->spec;
566                         eth_mask = (const struct rte_flow_item_eth *)item->mask;
567                         /* Get the MAC info. */
568                         if (!eth_spec || !eth_mask) {
569                                 rte_flow_error_set(error, EINVAL,
570                                                    RTE_FLOW_ERROR_TYPE_ITEM,
571                                                    item,
572                                                    "NULL ETH spec/mask");
573                                 return -rte_errno;
574                         }
575
576                         /* Mask bits of source MAC address must be full of 0.
577                          * Mask bits of destination MAC address must be full
578                          * of 1 or full of 0.
579                          */
580                         if (!is_zero_ether_addr(&eth_mask->src) ||
581                             (!is_zero_ether_addr(&eth_mask->dst) &&
582                              !is_broadcast_ether_addr(&eth_mask->dst))) {
583                                 rte_flow_error_set(error, EINVAL,
584                                                    RTE_FLOW_ERROR_TYPE_ITEM,
585                                                    item,
586                                                    "Invalid MAC_addr mask");
587                                 return -rte_errno;
588                         }
589
590                         if ((eth_mask->type & UINT16_MAX) != UINT16_MAX) {
591                                 rte_flow_error_set(error, EINVAL,
592                                                    RTE_FLOW_ERROR_TYPE_ITEM,
593                                                    item,
594                                                    "Invalid ethertype mask");
595                                 return -rte_errno;
596                         }
597
598                         /* If mask bits of destination MAC address
599                          * are full of 1, set RTE_ETHTYPE_FLAGS_MAC.
600                          */
601                         if (is_broadcast_ether_addr(&eth_mask->dst)) {
602                                 filter->mac_addr = eth_spec->dst;
603                                 filter->flags |= RTE_ETHTYPE_FLAGS_MAC;
604                         } else {
605                                 filter->flags &= ~RTE_ETHTYPE_FLAGS_MAC;
606                         }
607                         filter->ether_type = rte_be_to_cpu_16(eth_spec->type);
608
609                         if (filter->ether_type == ETHER_TYPE_IPv4 ||
610                             filter->ether_type == ETHER_TYPE_IPv6 ||
611                             filter->ether_type == ETHER_TYPE_LLDP ||
612                             filter->ether_type == outer_tpid) {
613                                 rte_flow_error_set(error, EINVAL,
614                                                    RTE_FLOW_ERROR_TYPE_ITEM,
615                                                    item,
616                                                    "Unsupported ether_type in"
617                                                    " control packet filter.");
618                                 return -rte_errno;
619                         }
620                         break;
621                 default:
622                         break;
623                 }
624         }
625
626         return 0;
627 }
628
629 /* Ethertype action only supports QUEUE or DROP. */
630 static int
631 i40e_flow_parse_ethertype_action(struct rte_eth_dev *dev,
632                                  const struct rte_flow_action *actions,
633                                  struct rte_flow_error *error,
634                                  struct rte_eth_ethertype_filter *filter)
635 {
636         struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
637         const struct rte_flow_action *act;
638         const struct rte_flow_action_queue *act_q;
639         uint32_t index = 0;
640
641         /* Check if the first non-void action is QUEUE or DROP. */
642         NEXT_ITEM_OF_ACTION(act, actions, index);
643         if (act->type != RTE_FLOW_ACTION_TYPE_QUEUE &&
644             act->type != RTE_FLOW_ACTION_TYPE_DROP) {
645                 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
646                                    act, "Not supported action.");
647                 return -rte_errno;
648         }
649
650         if (act->type == RTE_FLOW_ACTION_TYPE_QUEUE) {
651                 act_q = (const struct rte_flow_action_queue *)act->conf;
652                 filter->queue = act_q->index;
653                 if (filter->queue >= pf->dev_data->nb_rx_queues) {
654                         rte_flow_error_set(error, EINVAL,
655                                            RTE_FLOW_ERROR_TYPE_ACTION,
656                                            act, "Invalid queue ID for"
657                                            " ethertype_filter.");
658                         return -rte_errno;
659                 }
660         } else {
661                 filter->flags |= RTE_ETHTYPE_FLAGS_DROP;
662         }
663
664         /* Check if the next non-void item is END */
665         index++;
666         NEXT_ITEM_OF_ACTION(act, actions, index);
667         if (act->type != RTE_FLOW_ACTION_TYPE_END) {
668                 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
669                                    act, "Not supported action.");
670                 return -rte_errno;
671         }
672
673         return 0;
674 }
675
676 static int
677 i40e_flow_parse_ethertype_filter(struct rte_eth_dev *dev,
678                                  const struct rte_flow_attr *attr,
679                                  const struct rte_flow_item pattern[],
680                                  const struct rte_flow_action actions[],
681                                  struct rte_flow_error *error,
682                                  union i40e_filter_t *filter)
683 {
684         struct rte_eth_ethertype_filter *ethertype_filter =
685                 &filter->ethertype_filter;
686         int ret;
687
688         ret = i40e_flow_parse_ethertype_pattern(dev, pattern, error,
689                                                 ethertype_filter);
690         if (ret)
691                 return ret;
692
693         ret = i40e_flow_parse_ethertype_action(dev, actions, error,
694                                                ethertype_filter);
695         if (ret)
696                 return ret;
697
698         ret = i40e_flow_parse_attr(attr, error);
699         if (ret)
700                 return ret;
701
702         cons_filter_type = RTE_ETH_FILTER_ETHERTYPE;
703
704         return ret;
705 }
706
707 /* 1. Last in item should be NULL as range is not supported.
708  * 2. Supported flow type and input set: refer to array
709  *    default_inset_table in i40e_ethdev.c.
710  * 3. Mask of fields which need to be matched should be
711  *    filled with 1.
712  * 4. Mask of fields which needn't to be matched should be
713  *    filled with 0.
714  */
715 static int
716 i40e_flow_parse_fdir_pattern(struct rte_eth_dev *dev,
717                              const struct rte_flow_item *pattern,
718                              struct rte_flow_error *error,
719                              struct rte_eth_fdir_filter *filter)
720 {
721         struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
722         const struct rte_flow_item *item = pattern;
723         const struct rte_flow_item_eth *eth_spec, *eth_mask;
724         const struct rte_flow_item_ipv4 *ipv4_spec, *ipv4_mask;
725         const struct rte_flow_item_ipv6 *ipv6_spec, *ipv6_mask;
726         const struct rte_flow_item_tcp *tcp_spec, *tcp_mask;
727         const struct rte_flow_item_udp *udp_spec, *udp_mask;
728         const struct rte_flow_item_sctp *sctp_spec, *sctp_mask;
729         const struct rte_flow_item_vf *vf_spec;
730         uint32_t flow_type = RTE_ETH_FLOW_UNKNOWN;
731         enum i40e_filter_pctype pctype;
732         uint64_t input_set = I40E_INSET_NONE;
733         uint16_t flag_offset;
734         enum rte_flow_item_type item_type;
735         enum rte_flow_item_type l3 = RTE_FLOW_ITEM_TYPE_END;
736         uint32_t j;
737
738         for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
739                 if (item->last) {
740                         rte_flow_error_set(error, EINVAL,
741                                            RTE_FLOW_ERROR_TYPE_ITEM,
742                                            item,
743                                            "Not support range");
744                         return -rte_errno;
745                 }
746                 item_type = item->type;
747                 switch (item_type) {
748                 case RTE_FLOW_ITEM_TYPE_ETH:
749                         eth_spec = (const struct rte_flow_item_eth *)item->spec;
750                         eth_mask = (const struct rte_flow_item_eth *)item->mask;
751                         if (eth_spec || eth_mask) {
752                                 rte_flow_error_set(error, EINVAL,
753                                                    RTE_FLOW_ERROR_TYPE_ITEM,
754                                                    item,
755                                                    "Invalid ETH spec/mask");
756                                 return -rte_errno;
757                         }
758                         break;
759                 case RTE_FLOW_ITEM_TYPE_IPV4:
760                         l3 = RTE_FLOW_ITEM_TYPE_IPV4;
761                         ipv4_spec =
762                                 (const struct rte_flow_item_ipv4 *)item->spec;
763                         ipv4_mask =
764                                 (const struct rte_flow_item_ipv4 *)item->mask;
765                         if (!ipv4_spec || !ipv4_mask) {
766                                 rte_flow_error_set(error, EINVAL,
767                                                    RTE_FLOW_ERROR_TYPE_ITEM,
768                                                    item,
769                                                    "NULL IPv4 spec/mask");
770                                 return -rte_errno;
771                         }
772
773                         /* Check IPv4 mask and update input set */
774                         if (ipv4_mask->hdr.version_ihl ||
775                             ipv4_mask->hdr.total_length ||
776                             ipv4_mask->hdr.packet_id ||
777                             ipv4_mask->hdr.fragment_offset ||
778                             ipv4_mask->hdr.hdr_checksum) {
779                                 rte_flow_error_set(error, EINVAL,
780                                                    RTE_FLOW_ERROR_TYPE_ITEM,
781                                                    item,
782                                                    "Invalid IPv4 mask.");
783                                 return -rte_errno;
784                         }
785
786                         if (ipv4_mask->hdr.src_addr == UINT32_MAX)
787                                 input_set |= I40E_INSET_IPV4_SRC;
788                         if (ipv4_mask->hdr.dst_addr == UINT32_MAX)
789                                 input_set |= I40E_INSET_IPV4_DST;
790                         if (ipv4_mask->hdr.type_of_service == UINT8_MAX)
791                                 input_set |= I40E_INSET_IPV4_TOS;
792                         if (ipv4_mask->hdr.time_to_live == UINT8_MAX)
793                                 input_set |= I40E_INSET_IPV4_TTL;
794                         if (ipv4_mask->hdr.next_proto_id == UINT8_MAX)
795                                 input_set |= I40E_INSET_IPV4_PROTO;
796
797                         /* Get filter info */
798                         flow_type = RTE_ETH_FLOW_NONFRAG_IPV4_OTHER;
799                         /* Check if it is fragment. */
800                         flag_offset =
801                               rte_be_to_cpu_16(ipv4_spec->hdr.fragment_offset);
802                         if (flag_offset & IPV4_HDR_OFFSET_MASK ||
803                             flag_offset & IPV4_HDR_MF_FLAG)
804                                 flow_type = RTE_ETH_FLOW_FRAG_IPV4;
805
806                         /* Get the filter info */
807                         filter->input.flow.ip4_flow.proto =
808                                 ipv4_spec->hdr.next_proto_id;
809                         filter->input.flow.ip4_flow.tos =
810                                 ipv4_spec->hdr.type_of_service;
811                         filter->input.flow.ip4_flow.ttl =
812                                 ipv4_spec->hdr.time_to_live;
813                         filter->input.flow.ip4_flow.src_ip =
814                                 ipv4_spec->hdr.src_addr;
815                         filter->input.flow.ip4_flow.dst_ip =
816                                 ipv4_spec->hdr.dst_addr;
817
818                         break;
819                 case RTE_FLOW_ITEM_TYPE_IPV6:
820                         l3 = RTE_FLOW_ITEM_TYPE_IPV6;
821                         ipv6_spec =
822                                 (const struct rte_flow_item_ipv6 *)item->spec;
823                         ipv6_mask =
824                                 (const struct rte_flow_item_ipv6 *)item->mask;
825                         if (!ipv6_spec || !ipv6_mask) {
826                                 rte_flow_error_set(error, EINVAL,
827                                                    RTE_FLOW_ERROR_TYPE_ITEM,
828                                                    item,
829                                                    "NULL IPv6 spec/mask");
830                                 return -rte_errno;
831                         }
832
833                         /* Check IPv6 mask and update input set */
834                         if (ipv6_mask->hdr.payload_len) {
835                                 rte_flow_error_set(error, EINVAL,
836                                                    RTE_FLOW_ERROR_TYPE_ITEM,
837                                                    item,
838                                                    "Invalid IPv6 mask");
839                                 return -rte_errno;
840                         }
841
842                         /* SCR and DST address of IPv6 shouldn't be masked */
843                         for (j = 0; j < RTE_DIM(ipv6_mask->hdr.src_addr); j++) {
844                                 if (ipv6_mask->hdr.src_addr[j] != UINT8_MAX ||
845                                     ipv6_mask->hdr.dst_addr[j] != UINT8_MAX) {
846                                         rte_flow_error_set(error, EINVAL,
847                                                    RTE_FLOW_ERROR_TYPE_ITEM,
848                                                    item,
849                                                    "Invalid IPv6 mask");
850                                         return -rte_errno;
851                                 }
852                         }
853
854                         input_set |= I40E_INSET_IPV6_SRC;
855                         input_set |= I40E_INSET_IPV6_DST;
856
857                         if ((ipv6_mask->hdr.vtc_flow &
858                              rte_cpu_to_be_16(I40E_IPV6_TC_MASK))
859                             == rte_cpu_to_be_16(I40E_IPV6_TC_MASK))
860                                 input_set |= I40E_INSET_IPV6_TC;
861                         if (ipv6_mask->hdr.proto == UINT8_MAX)
862                                 input_set |= I40E_INSET_IPV6_NEXT_HDR;
863                         if (ipv6_mask->hdr.hop_limits == UINT8_MAX)
864                                 input_set |= I40E_INSET_IPV6_HOP_LIMIT;
865
866                         /* Get filter info */
867                         filter->input.flow.ipv6_flow.tc =
868                                 (uint8_t)(ipv6_spec->hdr.vtc_flow <<
869                                           I40E_IPV4_TC_SHIFT);
870                         filter->input.flow.ipv6_flow.proto =
871                                 ipv6_spec->hdr.proto;
872                         filter->input.flow.ipv6_flow.hop_limits =
873                                 ipv6_spec->hdr.hop_limits;
874
875                         rte_memcpy(filter->input.flow.ipv6_flow.src_ip,
876                                    ipv6_spec->hdr.src_addr, 16);
877                         rte_memcpy(filter->input.flow.ipv6_flow.dst_ip,
878                                    ipv6_spec->hdr.dst_addr, 16);
879
880                         /* Check if it is fragment. */
881                         if (ipv6_spec->hdr.proto == I40E_IPV6_FRAG_HEADER)
882                                 flow_type = RTE_ETH_FLOW_FRAG_IPV6;
883                         else
884                                 flow_type = RTE_ETH_FLOW_NONFRAG_IPV6_OTHER;
885                         break;
886                 case RTE_FLOW_ITEM_TYPE_TCP:
887                         tcp_spec = (const struct rte_flow_item_tcp *)item->spec;
888                         tcp_mask = (const struct rte_flow_item_tcp *)item->mask;
889                         if (!tcp_spec || !tcp_mask) {
890                                 rte_flow_error_set(error, EINVAL,
891                                                    RTE_FLOW_ERROR_TYPE_ITEM,
892                                                    item,
893                                                    "NULL TCP spec/mask");
894                                 return -rte_errno;
895                         }
896
897                         /* Check TCP mask and update input set */
898                         if (tcp_mask->hdr.sent_seq ||
899                             tcp_mask->hdr.recv_ack ||
900                             tcp_mask->hdr.data_off ||
901                             tcp_mask->hdr.tcp_flags ||
902                             tcp_mask->hdr.rx_win ||
903                             tcp_mask->hdr.cksum ||
904                             tcp_mask->hdr.tcp_urp) {
905                                 rte_flow_error_set(error, EINVAL,
906                                                    RTE_FLOW_ERROR_TYPE_ITEM,
907                                                    item,
908                                                    "Invalid TCP mask");
909                                 return -rte_errno;
910                         }
911
912                         if (tcp_mask->hdr.src_port != UINT16_MAX ||
913                             tcp_mask->hdr.dst_port != UINT16_MAX) {
914                                 rte_flow_error_set(error, EINVAL,
915                                                    RTE_FLOW_ERROR_TYPE_ITEM,
916                                                    item,
917                                                    "Invalid TCP mask");
918                                 return -rte_errno;
919                         }
920
921                         input_set |= I40E_INSET_SRC_PORT;
922                         input_set |= I40E_INSET_DST_PORT;
923
924                         /* Get filter info */
925                         if (l3 == RTE_FLOW_ITEM_TYPE_IPV4)
926                                 flow_type = RTE_ETH_FLOW_NONFRAG_IPV4_TCP;
927                         else if (l3 == RTE_FLOW_ITEM_TYPE_IPV6)
928                                 flow_type = RTE_ETH_FLOW_NONFRAG_IPV6_TCP;
929
930                         if (l3 == RTE_FLOW_ITEM_TYPE_IPV4) {
931                                 filter->input.flow.tcp4_flow.src_port =
932                                         tcp_spec->hdr.src_port;
933                                 filter->input.flow.tcp4_flow.dst_port =
934                                         tcp_spec->hdr.dst_port;
935                         } else if (l3 == RTE_FLOW_ITEM_TYPE_IPV6) {
936                                 filter->input.flow.tcp6_flow.src_port =
937                                         tcp_spec->hdr.src_port;
938                                 filter->input.flow.tcp6_flow.dst_port =
939                                         tcp_spec->hdr.dst_port;
940                         }
941                         break;
942                 case RTE_FLOW_ITEM_TYPE_UDP:
943                         udp_spec = (const struct rte_flow_item_udp *)item->spec;
944                         udp_mask = (const struct rte_flow_item_udp *)item->mask;
945                         if (!udp_spec || !udp_mask) {
946                                 rte_flow_error_set(error, EINVAL,
947                                                    RTE_FLOW_ERROR_TYPE_ITEM,
948                                                    item,
949                                                    "NULL UDP spec/mask");
950                                 return -rte_errno;
951                         }
952
953                         /* Check UDP mask and update input set*/
954                         if (udp_mask->hdr.dgram_len ||
955                             udp_mask->hdr.dgram_cksum) {
956                                 rte_flow_error_set(error, EINVAL,
957                                                    RTE_FLOW_ERROR_TYPE_ITEM,
958                                                    item,
959                                                    "Invalid UDP mask");
960                                 return -rte_errno;
961                         }
962
963                         if (udp_mask->hdr.src_port != UINT16_MAX ||
964                             udp_mask->hdr.dst_port != UINT16_MAX) {
965                                 rte_flow_error_set(error, EINVAL,
966                                                    RTE_FLOW_ERROR_TYPE_ITEM,
967                                                    item,
968                                                    "Invalid UDP mask");
969                                 return -rte_errno;
970                         }
971
972                         input_set |= I40E_INSET_SRC_PORT;
973                         input_set |= I40E_INSET_DST_PORT;
974
975                         /* Get filter info */
976                         if (l3 == RTE_FLOW_ITEM_TYPE_IPV4)
977                                 flow_type =
978                                         RTE_ETH_FLOW_NONFRAG_IPV4_UDP;
979                         else if (l3 == RTE_FLOW_ITEM_TYPE_IPV6)
980                                 flow_type =
981                                         RTE_ETH_FLOW_NONFRAG_IPV6_UDP;
982
983                         if (l3 == RTE_FLOW_ITEM_TYPE_IPV4) {
984                                 filter->input.flow.udp4_flow.src_port =
985                                         udp_spec->hdr.src_port;
986                                 filter->input.flow.udp4_flow.dst_port =
987                                         udp_spec->hdr.dst_port;
988                         } else if (l3 == RTE_FLOW_ITEM_TYPE_IPV6) {
989                                 filter->input.flow.udp6_flow.src_port =
990                                         udp_spec->hdr.src_port;
991                                 filter->input.flow.udp6_flow.dst_port =
992                                         udp_spec->hdr.dst_port;
993                         }
994                         break;
995                 case RTE_FLOW_ITEM_TYPE_SCTP:
996                         sctp_spec =
997                                 (const struct rte_flow_item_sctp *)item->spec;
998                         sctp_mask =
999                                 (const struct rte_flow_item_sctp *)item->mask;
1000                         if (!sctp_spec || !sctp_mask) {
1001                                 rte_flow_error_set(error, EINVAL,
1002                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1003                                                    item,
1004                                                    "NULL SCTP spec/mask");
1005                                 return -rte_errno;
1006                         }
1007
1008                         /* Check SCTP mask and update input set */
1009                         if (sctp_mask->hdr.cksum) {
1010                                 rte_flow_error_set(error, EINVAL,
1011                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1012                                                    item,
1013                                                    "Invalid UDP mask");
1014                                 return -rte_errno;
1015                         }
1016
1017                         if (sctp_mask->hdr.src_port != UINT16_MAX ||
1018                             sctp_mask->hdr.dst_port != UINT16_MAX ||
1019                             sctp_mask->hdr.tag != UINT32_MAX) {
1020                                 rte_flow_error_set(error, EINVAL,
1021                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1022                                                    item,
1023                                                    "Invalid UDP mask");
1024                                 return -rte_errno;
1025                         }
1026                         input_set |= I40E_INSET_SRC_PORT;
1027                         input_set |= I40E_INSET_DST_PORT;
1028                         input_set |= I40E_INSET_SCTP_VT;
1029
1030                         /* Get filter info */
1031                         if (l3 == RTE_FLOW_ITEM_TYPE_IPV4)
1032                                 flow_type = RTE_ETH_FLOW_NONFRAG_IPV4_SCTP;
1033                         else if (l3 == RTE_FLOW_ITEM_TYPE_IPV6)
1034                                 flow_type = RTE_ETH_FLOW_NONFRAG_IPV6_SCTP;
1035
1036                         if (l3 == RTE_FLOW_ITEM_TYPE_IPV4) {
1037                                 filter->input.flow.sctp4_flow.src_port =
1038                                         sctp_spec->hdr.src_port;
1039                                 filter->input.flow.sctp4_flow.dst_port =
1040                                         sctp_spec->hdr.dst_port;
1041                                 filter->input.flow.sctp4_flow.verify_tag =
1042                                         sctp_spec->hdr.tag;
1043                         } else if (l3 == RTE_FLOW_ITEM_TYPE_IPV6) {
1044                                 filter->input.flow.sctp6_flow.src_port =
1045                                         sctp_spec->hdr.src_port;
1046                                 filter->input.flow.sctp6_flow.dst_port =
1047                                         sctp_spec->hdr.dst_port;
1048                                 filter->input.flow.sctp6_flow.verify_tag =
1049                                         sctp_spec->hdr.tag;
1050                         }
1051                         break;
1052                 case RTE_FLOW_ITEM_TYPE_VF:
1053                         vf_spec = (const struct rte_flow_item_vf *)item->spec;
1054                         filter->input.flow_ext.is_vf = 1;
1055                         filter->input.flow_ext.dst_id = vf_spec->id;
1056                         if (filter->input.flow_ext.is_vf &&
1057                             filter->input.flow_ext.dst_id >= pf->vf_num) {
1058                                 rte_flow_error_set(error, EINVAL,
1059                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1060                                                    item,
1061                                                    "Invalid VF ID for FDIR.");
1062                                 return -rte_errno;
1063                         }
1064                         break;
1065                 default:
1066                         break;
1067                 }
1068         }
1069
1070         pctype = i40e_flowtype_to_pctype(flow_type);
1071         if (pctype == 0 || pctype > I40E_FILTER_PCTYPE_L2_PAYLOAD) {
1072                 rte_flow_error_set(error, EINVAL,
1073                                    RTE_FLOW_ERROR_TYPE_ITEM, item,
1074                                    "Unsupported flow type");
1075                 return -rte_errno;
1076         }
1077
1078         if (input_set != i40e_get_default_input_set(pctype)) {
1079                 rte_flow_error_set(error, EINVAL,
1080                                    RTE_FLOW_ERROR_TYPE_ITEM, item,
1081                                    "Invalid input set.");
1082                 return -rte_errno;
1083         }
1084         filter->input.flow_type = flow_type;
1085
1086         return 0;
1087 }
1088
1089 /* Parse to get the action info of a FDIR filter.
1090  * FDIR action supports QUEUE or (QUEUE + MARK).
1091  */
1092 static int
1093 i40e_flow_parse_fdir_action(struct rte_eth_dev *dev,
1094                             const struct rte_flow_action *actions,
1095                             struct rte_flow_error *error,
1096                             struct rte_eth_fdir_filter *filter)
1097 {
1098         struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
1099         const struct rte_flow_action *act;
1100         const struct rte_flow_action_queue *act_q;
1101         const struct rte_flow_action_mark *mark_spec;
1102         uint32_t index = 0;
1103
1104         /* Check if the first non-void action is QUEUE or DROP. */
1105         NEXT_ITEM_OF_ACTION(act, actions, index);
1106         if (act->type != RTE_FLOW_ACTION_TYPE_QUEUE &&
1107             act->type != RTE_FLOW_ACTION_TYPE_DROP) {
1108                 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
1109                                    act, "Invalid action.");
1110                 return -rte_errno;
1111         }
1112
1113         act_q = (const struct rte_flow_action_queue *)act->conf;
1114         filter->action.flex_off = 0;
1115         if (act->type == RTE_FLOW_ACTION_TYPE_QUEUE)
1116                 filter->action.behavior = RTE_ETH_FDIR_ACCEPT;
1117         else
1118                 filter->action.behavior = RTE_ETH_FDIR_REJECT;
1119
1120         filter->action.report_status = RTE_ETH_FDIR_REPORT_ID;
1121         filter->action.rx_queue = act_q->index;
1122
1123         if (filter->action.rx_queue >= pf->dev_data->nb_rx_queues) {
1124                 rte_flow_error_set(error, EINVAL,
1125                                    RTE_FLOW_ERROR_TYPE_ACTION, act,
1126                                    "Invalid queue ID for FDIR.");
1127                 return -rte_errno;
1128         }
1129
1130         /* Check if the next non-void item is MARK or END. */
1131         index++;
1132         NEXT_ITEM_OF_ACTION(act, actions, index);
1133         if (act->type != RTE_FLOW_ACTION_TYPE_MARK &&
1134             act->type != RTE_FLOW_ACTION_TYPE_END) {
1135                 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
1136                                    act, "Invalid action.");
1137                 return -rte_errno;
1138         }
1139
1140         if (act->type == RTE_FLOW_ACTION_TYPE_MARK) {
1141                 mark_spec = (const struct rte_flow_action_mark *)act->conf;
1142                 filter->soft_id = mark_spec->id;
1143
1144                 /* Check if the next non-void item is END */
1145                 index++;
1146                 NEXT_ITEM_OF_ACTION(act, actions, index);
1147                 if (act->type != RTE_FLOW_ACTION_TYPE_END) {
1148                         rte_flow_error_set(error, EINVAL,
1149                                            RTE_FLOW_ERROR_TYPE_ACTION,
1150                                            act, "Invalid action.");
1151                         return -rte_errno;
1152                 }
1153         }
1154
1155         return 0;
1156 }
1157
1158 static int
1159 i40e_flow_parse_fdir_filter(struct rte_eth_dev *dev,
1160                             const struct rte_flow_attr *attr,
1161                             const struct rte_flow_item pattern[],
1162                             const struct rte_flow_action actions[],
1163                             struct rte_flow_error *error,
1164                             union i40e_filter_t *filter)
1165 {
1166         struct rte_eth_fdir_filter *fdir_filter =
1167                 &filter->fdir_filter;
1168         int ret;
1169
1170         ret = i40e_flow_parse_fdir_pattern(dev, pattern, error, fdir_filter);
1171         if (ret)
1172                 return ret;
1173
1174         ret = i40e_flow_parse_fdir_action(dev, actions, error, fdir_filter);
1175         if (ret)
1176                 return ret;
1177
1178         ret = i40e_flow_parse_attr(attr, error);
1179         if (ret)
1180                 return ret;
1181
1182         cons_filter_type = RTE_ETH_FILTER_FDIR;
1183
1184         if (dev->data->dev_conf.fdir_conf.mode !=
1185             RTE_FDIR_MODE_PERFECT) {
1186                 rte_flow_error_set(error, ENOTSUP,
1187                                    RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
1188                                    NULL,
1189                                    "Check the mode in fdir_conf.");
1190                 return -rte_errno;
1191         }
1192
1193         return 0;
1194 }
1195
1196 /* Parse to get the action info of a tunnel filter
1197  * Tunnel action only supports PF, VF and QUEUE.
1198  */
1199 static int
1200 i40e_flow_parse_tunnel_action(struct rte_eth_dev *dev,
1201                               const struct rte_flow_action *actions,
1202                               struct rte_flow_error *error,
1203                               struct i40e_tunnel_filter_conf *filter)
1204 {
1205         struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
1206         const struct rte_flow_action *act;
1207         const struct rte_flow_action_queue *act_q;
1208         const struct rte_flow_action_vf *act_vf;
1209         uint32_t index = 0;
1210
1211         /* Check if the first non-void action is PF or VF. */
1212         NEXT_ITEM_OF_ACTION(act, actions, index);
1213         if (act->type != RTE_FLOW_ACTION_TYPE_PF &&
1214             act->type != RTE_FLOW_ACTION_TYPE_VF) {
1215                 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
1216                                    act, "Not supported action.");
1217                 return -rte_errno;
1218         }
1219
1220         if (act->type == RTE_FLOW_ACTION_TYPE_VF) {
1221                 act_vf = (const struct rte_flow_action_vf *)act->conf;
1222                 filter->vf_id = act_vf->id;
1223                 filter->is_to_vf = 1;
1224                 if (filter->vf_id >= pf->vf_num) {
1225                         rte_flow_error_set(error, EINVAL,
1226                                    RTE_FLOW_ERROR_TYPE_ACTION,
1227                                    act, "Invalid VF ID for tunnel filter");
1228                         return -rte_errno;
1229                 }
1230         }
1231
1232         /* Check if the next non-void item is QUEUE */
1233         index++;
1234         NEXT_ITEM_OF_ACTION(act, actions, index);
1235         if (act->type == RTE_FLOW_ACTION_TYPE_QUEUE) {
1236                 act_q = (const struct rte_flow_action_queue *)act->conf;
1237                 filter->queue_id = act_q->index;
1238                 if ((!filter->is_to_vf) &&
1239                     (filter->queue_id >= pf->dev_data->nb_rx_queues)) {
1240                         rte_flow_error_set(error, EINVAL,
1241                                    RTE_FLOW_ERROR_TYPE_ACTION,
1242                                    act, "Invalid queue ID for tunnel filter");
1243                         return -rte_errno;
1244                 } else if (filter->is_to_vf &&
1245                            (filter->queue_id >= pf->vf_nb_qps)) {
1246                         rte_flow_error_set(error, EINVAL,
1247                                    RTE_FLOW_ERROR_TYPE_ACTION,
1248                                    act, "Invalid queue ID for tunnel filter");
1249                         return -rte_errno;
1250                 }
1251         }
1252
1253         /* Check if the next non-void item is END */
1254         index++;
1255         NEXT_ITEM_OF_ACTION(act, actions, index);
1256         if (act->type != RTE_FLOW_ACTION_TYPE_END) {
1257                 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
1258                                    act, "Not supported action.");
1259                 return -rte_errno;
1260         }
1261
1262         return 0;
1263 }
1264
1265 static int
1266 i40e_check_tenant_id_mask(const uint8_t *mask)
1267 {
1268         uint32_t j;
1269         int is_masked = 0;
1270
1271         for (j = 0; j < I40E_TENANT_ARRAY_NUM; j++) {
1272                 if (*(mask + j) == UINT8_MAX) {
1273                         if (j > 0 && (*(mask + j) != *(mask + j - 1)))
1274                                 return -EINVAL;
1275                         is_masked = 0;
1276                 } else if (*(mask + j) == 0) {
1277                         if (j > 0 && (*(mask + j) != *(mask + j - 1)))
1278                                 return -EINVAL;
1279                         is_masked = 1;
1280                 } else {
1281                         return -EINVAL;
1282                 }
1283         }
1284
1285         return is_masked;
1286 }
1287
1288 /* 1. Last in item should be NULL as range is not supported.
1289  * 2. Supported filter types: IMAC_IVLAN_TENID, IMAC_IVLAN,
1290  *    IMAC_TENID, OMAC_TENID_IMAC and IMAC.
1291  * 3. Mask of fields which need to be matched should be
1292  *    filled with 1.
1293  * 4. Mask of fields which needn't to be matched should be
1294  *    filled with 0.
1295  */
1296 static int
1297 i40e_flow_parse_vxlan_pattern(__rte_unused struct rte_eth_dev *dev,
1298                               const struct rte_flow_item *pattern,
1299                               struct rte_flow_error *error,
1300                               struct i40e_tunnel_filter_conf *filter)
1301 {
1302         const struct rte_flow_item *item = pattern;
1303         const struct rte_flow_item_eth *eth_spec;
1304         const struct rte_flow_item_eth *eth_mask;
1305         const struct rte_flow_item_eth *o_eth_spec = NULL;
1306         const struct rte_flow_item_eth *o_eth_mask = NULL;
1307         const struct rte_flow_item_vxlan *vxlan_spec = NULL;
1308         const struct rte_flow_item_vxlan *vxlan_mask = NULL;
1309         const struct rte_flow_item_eth *i_eth_spec = NULL;
1310         const struct rte_flow_item_eth *i_eth_mask = NULL;
1311         const struct rte_flow_item_vlan *vlan_spec = NULL;
1312         const struct rte_flow_item_vlan *vlan_mask = NULL;
1313         bool is_vni_masked = 0;
1314         enum rte_flow_item_type item_type;
1315         bool vxlan_flag = 0;
1316         uint32_t tenant_id_be = 0;
1317
1318         for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
1319                 if (item->last) {
1320                         rte_flow_error_set(error, EINVAL,
1321                                            RTE_FLOW_ERROR_TYPE_ITEM,
1322                                            item,
1323                                            "Not support range");
1324                         return -rte_errno;
1325                 }
1326                 item_type = item->type;
1327                 switch (item_type) {
1328                 case RTE_FLOW_ITEM_TYPE_ETH:
1329                         eth_spec = (const struct rte_flow_item_eth *)item->spec;
1330                         eth_mask = (const struct rte_flow_item_eth *)item->mask;
1331                         if ((!eth_spec && eth_mask) ||
1332                             (eth_spec && !eth_mask)) {
1333                                 rte_flow_error_set(error, EINVAL,
1334                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1335                                                    item,
1336                                                    "Invalid ether spec/mask");
1337                                 return -rte_errno;
1338                         }
1339
1340                         if (eth_spec && eth_mask) {
1341                                 /* DST address of inner MAC shouldn't be masked.
1342                                  * SRC address of Inner MAC should be masked.
1343                                  */
1344                                 if (!is_broadcast_ether_addr(&eth_mask->dst) ||
1345                                     !is_zero_ether_addr(&eth_mask->src) ||
1346                                     eth_mask->type) {
1347                                         rte_flow_error_set(error, EINVAL,
1348                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1349                                                    item,
1350                                                    "Invalid ether spec/mask");
1351                                         return -rte_errno;
1352                                 }
1353
1354                                 if (!vxlan_flag)
1355                                         rte_memcpy(&filter->outer_mac,
1356                                                    &eth_spec->dst,
1357                                                    ETHER_ADDR_LEN);
1358                                 else
1359                                         rte_memcpy(&filter->inner_mac,
1360                                                    &eth_spec->dst,
1361                                                    ETHER_ADDR_LEN);
1362                         }
1363
1364                         if (!vxlan_flag) {
1365                                 o_eth_spec = eth_spec;
1366                                 o_eth_mask = eth_mask;
1367                         } else {
1368                                 i_eth_spec = eth_spec;
1369                                 i_eth_mask = eth_mask;
1370                         }
1371
1372                         break;
1373                 case RTE_FLOW_ITEM_TYPE_VLAN:
1374                         vlan_spec =
1375                                 (const struct rte_flow_item_vlan *)item->spec;
1376                         vlan_mask =
1377                                 (const struct rte_flow_item_vlan *)item->mask;
1378                         if (vxlan_flag) {
1379                                 vlan_spec =
1380                                 (const struct rte_flow_item_vlan *)item->spec;
1381                                 vlan_mask =
1382                                 (const struct rte_flow_item_vlan *)item->mask;
1383                                 if (!(vlan_spec && vlan_mask)) {
1384                                         rte_flow_error_set(error, EINVAL,
1385                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1386                                                    item,
1387                                                    "Invalid vlan item");
1388                                         return -rte_errno;
1389                                 }
1390                         } else {
1391                                 if (vlan_spec || vlan_mask)
1392                                         rte_flow_error_set(error, EINVAL,
1393                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1394                                                    item,
1395                                                    "Invalid vlan item");
1396                                 return -rte_errno;
1397                         }
1398                         break;
1399                 case RTE_FLOW_ITEM_TYPE_IPV4:
1400                         filter->ip_type = I40E_TUNNEL_IPTYPE_IPV4;
1401                         /* IPv4 is used to describe protocol,
1402                          * spec and mask should be NULL.
1403                          */
1404                         if (item->spec || item->mask) {
1405                                 rte_flow_error_set(error, EINVAL,
1406                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1407                                                    item,
1408                                                    "Invalid IPv4 item");
1409                                 return -rte_errno;
1410                         }
1411                         break;
1412                 case RTE_FLOW_ITEM_TYPE_IPV6:
1413                         filter->ip_type = I40E_TUNNEL_IPTYPE_IPV6;
1414                         /* IPv6 is used to describe protocol,
1415                          * spec and mask should be NULL.
1416                          */
1417                         if (item->spec || item->mask) {
1418                                 rte_flow_error_set(error, EINVAL,
1419                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1420                                                    item,
1421                                                    "Invalid IPv6 item");
1422                                 return -rte_errno;
1423                         }
1424                         break;
1425                 case RTE_FLOW_ITEM_TYPE_UDP:
1426                         /* UDP is used to describe protocol,
1427                          * spec and mask should be NULL.
1428                          */
1429                         if (item->spec || item->mask) {
1430                                 rte_flow_error_set(error, EINVAL,
1431                                            RTE_FLOW_ERROR_TYPE_ITEM,
1432                                            item,
1433                                            "Invalid UDP item");
1434                                 return -rte_errno;
1435                         }
1436                         break;
1437                 case RTE_FLOW_ITEM_TYPE_VXLAN:
1438                         vxlan_spec =
1439                                 (const struct rte_flow_item_vxlan *)item->spec;
1440                         vxlan_mask =
1441                                 (const struct rte_flow_item_vxlan *)item->mask;
1442                         /* Check if VXLAN item is used to describe protocol.
1443                          * If yes, both spec and mask should be NULL.
1444                          * If no, either spec or mask shouldn't be NULL.
1445                          */
1446                         if ((!vxlan_spec && vxlan_mask) ||
1447                             (vxlan_spec && !vxlan_mask)) {
1448                                 rte_flow_error_set(error, EINVAL,
1449                                            RTE_FLOW_ERROR_TYPE_ITEM,
1450                                            item,
1451                                            "Invalid VXLAN item");
1452                                 return -rte_errno;
1453                         }
1454
1455                         /* Check if VNI is masked. */
1456                         if (vxlan_mask) {
1457                                 is_vni_masked =
1458                                 i40e_check_tenant_id_mask(vxlan_mask->vni);
1459                                 if (is_vni_masked < 0) {
1460                                         rte_flow_error_set(error, EINVAL,
1461                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1462                                                    item,
1463                                                    "Invalid VNI mask");
1464                                         return -rte_errno;
1465                                 }
1466                         }
1467                         vxlan_flag = 1;
1468                         break;
1469                 default:
1470                         break;
1471                 }
1472         }
1473
1474         /* Check specification and mask to get the filter type */
1475         if (vlan_spec && vlan_mask &&
1476             (vlan_mask->tci == rte_cpu_to_be_16(I40E_TCI_MASK))) {
1477                 /* If there's inner vlan */
1478                 filter->inner_vlan = rte_be_to_cpu_16(vlan_spec->tci)
1479                         & I40E_TCI_MASK;
1480                 if (vxlan_spec && vxlan_mask && !is_vni_masked) {
1481                         /* If there's vxlan */
1482                         rte_memcpy(((uint8_t *)&tenant_id_be + 1),
1483                                    vxlan_spec->vni, 3);
1484                         filter->tenant_id = rte_be_to_cpu_32(tenant_id_be);
1485                         if (!o_eth_spec && !o_eth_mask &&
1486                                 i_eth_spec && i_eth_mask)
1487                                 filter->filter_type =
1488                                         RTE_TUNNEL_FILTER_IMAC_IVLAN_TENID;
1489                         else {
1490                                 rte_flow_error_set(error, EINVAL,
1491                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1492                                                    NULL,
1493                                                    "Invalid filter type");
1494                                 return -rte_errno;
1495                         }
1496                 } else if (!vxlan_spec && !vxlan_mask) {
1497                         /* If there's no vxlan */
1498                         if (!o_eth_spec && !o_eth_mask &&
1499                                 i_eth_spec && i_eth_mask)
1500                                 filter->filter_type =
1501                                         RTE_TUNNEL_FILTER_IMAC_IVLAN;
1502                         else {
1503                                 rte_flow_error_set(error, EINVAL,
1504                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1505                                                    NULL,
1506                                                    "Invalid filter type");
1507                                 return -rte_errno;
1508                         }
1509                 } else {
1510                         rte_flow_error_set(error, EINVAL,
1511                                            RTE_FLOW_ERROR_TYPE_ITEM,
1512                                            NULL,
1513                                            "Invalid filter type");
1514                         return -rte_errno;
1515                 }
1516         } else if ((!vlan_spec && !vlan_mask) ||
1517                    (vlan_spec && vlan_mask && vlan_mask->tci == 0x0)) {
1518                 /* If there's no inner vlan */
1519                 if (vxlan_spec && vxlan_mask && !is_vni_masked) {
1520                         /* If there's vxlan */
1521                         rte_memcpy(((uint8_t *)&tenant_id_be + 1),
1522                                    vxlan_spec->vni, 3);
1523                         filter->tenant_id = rte_be_to_cpu_32(tenant_id_be);
1524                         if (!o_eth_spec && !o_eth_mask &&
1525                                 i_eth_spec && i_eth_mask)
1526                                 filter->filter_type =
1527                                         RTE_TUNNEL_FILTER_IMAC_TENID;
1528                         else if (o_eth_spec && o_eth_mask &&
1529                                 i_eth_spec && i_eth_mask)
1530                                 filter->filter_type =
1531                                         RTE_TUNNEL_FILTER_OMAC_TENID_IMAC;
1532                 } else if (!vxlan_spec && !vxlan_mask) {
1533                         /* If there's no vxlan */
1534                         if (!o_eth_spec && !o_eth_mask &&
1535                                 i_eth_spec && i_eth_mask) {
1536                                 filter->filter_type = ETH_TUNNEL_FILTER_IMAC;
1537                         } else {
1538                                 rte_flow_error_set(error, EINVAL,
1539                                            RTE_FLOW_ERROR_TYPE_ITEM, NULL,
1540                                            "Invalid filter type");
1541                                 return -rte_errno;
1542                         }
1543                 } else {
1544                         rte_flow_error_set(error, EINVAL,
1545                                            RTE_FLOW_ERROR_TYPE_ITEM, NULL,
1546                                            "Invalid filter type");
1547                         return -rte_errno;
1548                 }
1549         } else {
1550                 rte_flow_error_set(error, EINVAL,
1551                                    RTE_FLOW_ERROR_TYPE_ITEM, NULL,
1552                                    "Not supported by tunnel filter.");
1553                 return -rte_errno;
1554         }
1555
1556         filter->tunnel_type = I40E_TUNNEL_TYPE_VXLAN;
1557
1558         return 0;
1559 }
1560
1561 static int
1562 i40e_flow_parse_vxlan_filter(struct rte_eth_dev *dev,
1563                              const struct rte_flow_attr *attr,
1564                              const struct rte_flow_item pattern[],
1565                              const struct rte_flow_action actions[],
1566                              struct rte_flow_error *error,
1567                              union i40e_filter_t *filter)
1568 {
1569         struct i40e_tunnel_filter_conf *tunnel_filter =
1570                 &filter->consistent_tunnel_filter;
1571         int ret;
1572
1573         ret = i40e_flow_parse_vxlan_pattern(dev, pattern,
1574                                             error, tunnel_filter);
1575         if (ret)
1576                 return ret;
1577
1578         ret = i40e_flow_parse_tunnel_action(dev, actions, error, tunnel_filter);
1579         if (ret)
1580                 return ret;
1581
1582         ret = i40e_flow_parse_attr(attr, error);
1583         if (ret)
1584                 return ret;
1585
1586         cons_filter_type = RTE_ETH_FILTER_TUNNEL;
1587
1588         return ret;
1589 }
1590
1591 /* 1. Last in item should be NULL as range is not supported.
1592  * 2. Supported filter types: MPLS label.
1593  * 3. Mask of fields which need to be matched should be
1594  *    filled with 1.
1595  * 4. Mask of fields which needn't to be matched should be
1596  *    filled with 0.
1597  */
1598 static int
1599 i40e_flow_parse_mpls_pattern(__rte_unused struct rte_eth_dev *dev,
1600                              const struct rte_flow_item *pattern,
1601                              struct rte_flow_error *error,
1602                              struct i40e_tunnel_filter_conf *filter)
1603 {
1604         const struct rte_flow_item *item = pattern;
1605         const struct rte_flow_item_mpls *mpls_spec;
1606         const struct rte_flow_item_mpls *mpls_mask;
1607         enum rte_flow_item_type item_type;
1608         bool is_mplsoudp = 0; /* 1 - MPLSoUDP, 0 - MPLSoGRE */
1609         const uint8_t label_mask[3] = {0xFF, 0xFF, 0xF0};
1610         uint32_t label_be = 0;
1611
1612         for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
1613                 if (item->last) {
1614                         rte_flow_error_set(error, EINVAL,
1615                                            RTE_FLOW_ERROR_TYPE_ITEM,
1616                                            item,
1617                                            "Not support range");
1618                         return -rte_errno;
1619                 }
1620                 item_type = item->type;
1621                 switch (item_type) {
1622                 case RTE_FLOW_ITEM_TYPE_ETH:
1623                         if (item->spec || item->mask) {
1624                                 rte_flow_error_set(error, EINVAL,
1625                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1626                                                    item,
1627                                                    "Invalid ETH item");
1628                                 return -rte_errno;
1629                         }
1630                         break;
1631                 case RTE_FLOW_ITEM_TYPE_IPV4:
1632                         filter->ip_type = I40E_TUNNEL_IPTYPE_IPV4;
1633                         /* IPv4 is used to describe protocol,
1634                          * spec and mask should be NULL.
1635                          */
1636                         if (item->spec || item->mask) {
1637                                 rte_flow_error_set(error, EINVAL,
1638                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1639                                                    item,
1640                                                    "Invalid IPv4 item");
1641                                 return -rte_errno;
1642                         }
1643                         break;
1644                 case RTE_FLOW_ITEM_TYPE_IPV6:
1645                         filter->ip_type = I40E_TUNNEL_IPTYPE_IPV6;
1646                         /* IPv6 is used to describe protocol,
1647                          * spec and mask should be NULL.
1648                          */
1649                         if (item->spec || item->mask) {
1650                                 rte_flow_error_set(error, EINVAL,
1651                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1652                                                    item,
1653                                                    "Invalid IPv6 item");
1654                                 return -rte_errno;
1655                         }
1656                         break;
1657                 case RTE_FLOW_ITEM_TYPE_UDP:
1658                         /* UDP is used to describe protocol,
1659                          * spec and mask should be NULL.
1660                          */
1661                         if (item->spec || item->mask) {
1662                                 rte_flow_error_set(error, EINVAL,
1663                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1664                                                    item,
1665                                                    "Invalid UDP item");
1666                                 return -rte_errno;
1667                         }
1668                         is_mplsoudp = 1;
1669                         break;
1670                 case RTE_FLOW_ITEM_TYPE_GRE:
1671                         /* GRE is used to describe protocol,
1672                          * spec and mask should be NULL.
1673                          */
1674                         if (item->spec || item->mask) {
1675                                 rte_flow_error_set(error, EINVAL,
1676                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1677                                                    item,
1678                                                    "Invalid GRE item");
1679                                 return -rte_errno;
1680                         }
1681                         break;
1682                 case RTE_FLOW_ITEM_TYPE_MPLS:
1683                         mpls_spec =
1684                                 (const struct rte_flow_item_mpls *)item->spec;
1685                         mpls_mask =
1686                                 (const struct rte_flow_item_mpls *)item->mask;
1687
1688                         if (!mpls_spec || !mpls_mask) {
1689                                 rte_flow_error_set(error, EINVAL,
1690                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1691                                                    item,
1692                                                    "Invalid MPLS item");
1693                                 return -rte_errno;
1694                         }
1695
1696                         if (memcmp(mpls_mask->label_tc_s, label_mask, 3)) {
1697                                 rte_flow_error_set(error, EINVAL,
1698                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1699                                                    item,
1700                                                    "Invalid MPLS label mask");
1701                                 return -rte_errno;
1702                         }
1703                         rte_memcpy(((uint8_t *)&label_be + 1),
1704                                    mpls_spec->label_tc_s, 3);
1705                         filter->tenant_id = rte_be_to_cpu_32(label_be) >> 4;
1706                         break;
1707                 default:
1708                         break;
1709                 }
1710         }
1711
1712         if (is_mplsoudp)
1713                 filter->tunnel_type = I40E_TUNNEL_TYPE_MPLSoUDP;
1714         else
1715                 filter->tunnel_type = I40E_TUNNEL_TYPE_MPLSoGRE;
1716
1717         return 0;
1718 }
1719
1720 static int
1721 i40e_flow_parse_mpls_filter(struct rte_eth_dev *dev,
1722                             const struct rte_flow_attr *attr,
1723                             const struct rte_flow_item pattern[],
1724                             const struct rte_flow_action actions[],
1725                             struct rte_flow_error *error,
1726                             union i40e_filter_t *filter)
1727 {
1728         struct i40e_tunnel_filter_conf *tunnel_filter =
1729                 &filter->consistent_tunnel_filter;
1730         int ret;
1731
1732         ret = i40e_flow_parse_mpls_pattern(dev, pattern,
1733                                            error, tunnel_filter);
1734         if (ret)
1735                 return ret;
1736
1737         ret = i40e_flow_parse_tunnel_action(dev, actions, error, tunnel_filter);
1738         if (ret)
1739                 return ret;
1740
1741         ret = i40e_flow_parse_attr(attr, error);
1742         if (ret)
1743                 return ret;
1744
1745         cons_filter_type = RTE_ETH_FILTER_TUNNEL;
1746
1747         return ret;
1748 }
1749
1750 /* 1. Last in item should be NULL as range is not supported.
1751  * 2. Supported filter types: QINQ.
1752  * 3. Mask of fields which need to be matched should be
1753  *    filled with 1.
1754  * 4. Mask of fields which needn't to be matched should be
1755  *    filled with 0.
1756  */
1757 static int
1758 i40e_flow_parse_qinq_pattern(__rte_unused struct rte_eth_dev *dev,
1759                               const struct rte_flow_item *pattern,
1760                               struct rte_flow_error *error,
1761                               struct i40e_tunnel_filter_conf *filter)
1762 {
1763         const struct rte_flow_item *item = pattern;
1764         const struct rte_flow_item_vlan *vlan_spec = NULL;
1765         const struct rte_flow_item_vlan *vlan_mask = NULL;
1766         const struct rte_flow_item_vlan *i_vlan_spec = NULL;
1767         const struct rte_flow_item_vlan *i_vlan_mask = NULL;
1768         const struct rte_flow_item_vlan *o_vlan_spec = NULL;
1769         const struct rte_flow_item_vlan *o_vlan_mask = NULL;
1770
1771         enum rte_flow_item_type item_type;
1772         bool vlan_flag = 0;
1773
1774         for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
1775                 if (item->last) {
1776                         rte_flow_error_set(error, EINVAL,
1777                                            RTE_FLOW_ERROR_TYPE_ITEM,
1778                                            item,
1779                                            "Not support range");
1780                         return -rte_errno;
1781                 }
1782                 item_type = item->type;
1783                 switch (item_type) {
1784                 case RTE_FLOW_ITEM_TYPE_ETH:
1785                         if (item->spec || item->mask) {
1786                                 rte_flow_error_set(error, EINVAL,
1787                                                    RTE_FLOW_ERROR_TYPE_ITEM,
1788                                                    item,
1789                                                    "Invalid ETH item");
1790                                 return -rte_errno;
1791                         }
1792                         break;
1793                 case RTE_FLOW_ITEM_TYPE_VLAN:
1794                         vlan_spec =
1795                                 (const struct rte_flow_item_vlan *)item->spec;
1796                         vlan_mask =
1797                                 (const struct rte_flow_item_vlan *)item->mask;
1798
1799                         if (!(vlan_spec && vlan_mask)) {
1800                                 rte_flow_error_set(error, EINVAL,
1801                                            RTE_FLOW_ERROR_TYPE_ITEM,
1802                                            item,
1803                                            "Invalid vlan item");
1804                                 return -rte_errno;
1805                         }
1806
1807                         if (!vlan_flag) {
1808                                 o_vlan_spec = vlan_spec;
1809                                 o_vlan_mask = vlan_mask;
1810                                 vlan_flag = 1;
1811                         } else {
1812                                 i_vlan_spec = vlan_spec;
1813                                 i_vlan_mask = vlan_mask;
1814                                 vlan_flag = 0;
1815                         }
1816                         break;
1817
1818                 default:
1819                         break;
1820                 }
1821         }
1822
1823         /* Get filter specification */
1824         if ((o_vlan_mask->tci == rte_cpu_to_be_16(I40E_TCI_MASK)) &&
1825             (i_vlan_mask->tci == rte_cpu_to_be_16(I40E_TCI_MASK))) {
1826                 filter->outer_vlan = rte_be_to_cpu_16(o_vlan_spec->tci)
1827                         & I40E_TCI_MASK;
1828                 filter->inner_vlan = rte_be_to_cpu_16(i_vlan_spec->tci)
1829                         & I40E_TCI_MASK;
1830         } else {
1831                         rte_flow_error_set(error, EINVAL,
1832                                            RTE_FLOW_ERROR_TYPE_ITEM,
1833                                            NULL,
1834                                            "Invalid filter type");
1835                         return -rte_errno;
1836         }
1837
1838         filter->tunnel_type = I40E_TUNNEL_TYPE_QINQ;
1839         return 0;
1840 }
1841
1842 static int
1843 i40e_flow_parse_qinq_filter(struct rte_eth_dev *dev,
1844                               const struct rte_flow_attr *attr,
1845                               const struct rte_flow_item pattern[],
1846                               const struct rte_flow_action actions[],
1847                               struct rte_flow_error *error,
1848                               union i40e_filter_t *filter)
1849 {
1850         struct i40e_tunnel_filter_conf *tunnel_filter =
1851                 &filter->consistent_tunnel_filter;
1852         int ret;
1853
1854         ret = i40e_flow_parse_qinq_pattern(dev, pattern,
1855                                              error, tunnel_filter);
1856         if (ret)
1857                 return ret;
1858
1859         ret = i40e_flow_parse_tunnel_action(dev, actions, error, tunnel_filter);
1860         if (ret)
1861                 return ret;
1862
1863         ret = i40e_flow_parse_attr(attr, error);
1864         if (ret)
1865                 return ret;
1866
1867         cons_filter_type = RTE_ETH_FILTER_TUNNEL;
1868
1869         return ret;
1870 }
1871
1872 static int
1873 i40e_flow_validate(struct rte_eth_dev *dev,
1874                    const struct rte_flow_attr *attr,
1875                    const struct rte_flow_item pattern[],
1876                    const struct rte_flow_action actions[],
1877                    struct rte_flow_error *error)
1878 {
1879         struct rte_flow_item *items; /* internal pattern w/o VOID items */
1880         parse_filter_t parse_filter;
1881         uint32_t item_num = 0; /* non-void item number of pattern*/
1882         uint32_t i = 0;
1883         int ret;
1884
1885         if (!pattern) {
1886                 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_NUM,
1887                                    NULL, "NULL pattern.");
1888                 return -rte_errno;
1889         }
1890
1891         if (!actions) {
1892                 rte_flow_error_set(error, EINVAL,
1893                                    RTE_FLOW_ERROR_TYPE_ACTION_NUM,
1894                                    NULL, "NULL action.");
1895                 return -rte_errno;
1896         }
1897
1898         if (!attr) {
1899                 rte_flow_error_set(error, EINVAL,
1900                                    RTE_FLOW_ERROR_TYPE_ATTR,
1901                                    NULL, "NULL attribute.");
1902                 return -rte_errno;
1903         }
1904
1905         memset(&cons_filter, 0, sizeof(cons_filter));
1906
1907         /* Get the non-void item number of pattern */
1908         while ((pattern + i)->type != RTE_FLOW_ITEM_TYPE_END) {
1909                 if ((pattern + i)->type != RTE_FLOW_ITEM_TYPE_VOID)
1910                         item_num++;
1911                 i++;
1912         }
1913         item_num++;
1914
1915         items = rte_zmalloc("i40e_pattern",
1916                             item_num * sizeof(struct rte_flow_item), 0);
1917         if (!items) {
1918                 rte_flow_error_set(error, ENOMEM, RTE_FLOW_ERROR_TYPE_ITEM_NUM,
1919                                    NULL, "No memory for PMD internal items.");
1920                 return -ENOMEM;
1921         }
1922
1923         i40e_pattern_skip_void_item(items, pattern);
1924
1925         /* Find if there's matched parse filter function */
1926         parse_filter = i40e_find_parse_filter_func(items);
1927         if (!parse_filter) {
1928                 rte_flow_error_set(error, EINVAL,
1929                                    RTE_FLOW_ERROR_TYPE_ITEM,
1930                                    pattern, "Unsupported pattern");
1931                 return -rte_errno;
1932         }
1933
1934         ret = parse_filter(dev, attr, items, actions, error, &cons_filter);
1935
1936         rte_free(items);
1937
1938         return ret;
1939 }
1940
1941 static struct rte_flow *
1942 i40e_flow_create(struct rte_eth_dev *dev,
1943                  const struct rte_flow_attr *attr,
1944                  const struct rte_flow_item pattern[],
1945                  const struct rte_flow_action actions[],
1946                  struct rte_flow_error *error)
1947 {
1948         struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
1949         struct rte_flow *flow;
1950         int ret;
1951
1952         flow = rte_zmalloc("i40e_flow", sizeof(struct rte_flow), 0);
1953         if (!flow) {
1954                 rte_flow_error_set(error, ENOMEM,
1955                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
1956                                    "Failed to allocate memory");
1957                 return flow;
1958         }
1959
1960         ret = i40e_flow_validate(dev, attr, pattern, actions, error);
1961         if (ret < 0)
1962                 return NULL;
1963
1964         switch (cons_filter_type) {
1965         case RTE_ETH_FILTER_ETHERTYPE:
1966                 ret = i40e_ethertype_filter_set(pf,
1967                                         &cons_filter.ethertype_filter, 1);
1968                 if (ret)
1969                         goto free_flow;
1970                 flow->rule = TAILQ_LAST(&pf->ethertype.ethertype_list,
1971                                         i40e_ethertype_filter_list);
1972                 break;
1973         case RTE_ETH_FILTER_FDIR:
1974                 ret = i40e_add_del_fdir_filter(dev,
1975                                        &cons_filter.fdir_filter, 1);
1976                 if (ret)
1977                         goto free_flow;
1978                 flow->rule = TAILQ_LAST(&pf->fdir.fdir_list,
1979                                         i40e_fdir_filter_list);
1980                 break;
1981         case RTE_ETH_FILTER_TUNNEL:
1982                 ret = i40e_dev_consistent_tunnel_filter_set(pf,
1983                             &cons_filter.consistent_tunnel_filter, 1);
1984                 if (ret)
1985                         goto free_flow;
1986                 flow->rule = TAILQ_LAST(&pf->tunnel.tunnel_list,
1987                                         i40e_tunnel_filter_list);
1988                 break;
1989         default:
1990                 goto free_flow;
1991         }
1992
1993         flow->filter_type = cons_filter_type;
1994         TAILQ_INSERT_TAIL(&pf->flow_list, flow, node);
1995         return flow;
1996
1997 free_flow:
1998         rte_flow_error_set(error, -ret,
1999                            RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
2000                            "Failed to create flow.");
2001         rte_free(flow);
2002         return NULL;
2003 }
2004
2005 static int
2006 i40e_flow_destroy(struct rte_eth_dev *dev,
2007                   struct rte_flow *flow,
2008                   struct rte_flow_error *error)
2009 {
2010         struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
2011         enum rte_filter_type filter_type = flow->filter_type;
2012         int ret = 0;
2013
2014         switch (filter_type) {
2015         case RTE_ETH_FILTER_ETHERTYPE:
2016                 ret = i40e_flow_destroy_ethertype_filter(pf,
2017                          (struct i40e_ethertype_filter *)flow->rule);
2018                 break;
2019         case RTE_ETH_FILTER_TUNNEL:
2020                 ret = i40e_flow_destroy_tunnel_filter(pf,
2021                               (struct i40e_tunnel_filter *)flow->rule);
2022                 break;
2023         case RTE_ETH_FILTER_FDIR:
2024                 ret = i40e_add_del_fdir_filter(dev,
2025                        &((struct i40e_fdir_filter *)flow->rule)->fdir, 0);
2026                 break;
2027         default:
2028                 PMD_DRV_LOG(WARNING, "Filter type (%d) not supported",
2029                             filter_type);
2030                 ret = -EINVAL;
2031                 break;
2032         }
2033
2034         if (!ret) {
2035                 TAILQ_REMOVE(&pf->flow_list, flow, node);
2036                 rte_free(flow);
2037         } else
2038                 rte_flow_error_set(error, -ret,
2039                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
2040                                    "Failed to destroy flow.");
2041
2042         return ret;
2043 }
2044
2045 static int
2046 i40e_flow_destroy_ethertype_filter(struct i40e_pf *pf,
2047                                    struct i40e_ethertype_filter *filter)
2048 {
2049         struct i40e_hw *hw = I40E_PF_TO_HW(pf);
2050         struct i40e_ethertype_rule *ethertype_rule = &pf->ethertype;
2051         struct i40e_ethertype_filter *node;
2052         struct i40e_control_filter_stats stats;
2053         uint16_t flags = 0;
2054         int ret = 0;
2055
2056         if (!(filter->flags & RTE_ETHTYPE_FLAGS_MAC))
2057                 flags |= I40E_AQC_ADD_CONTROL_PACKET_FLAGS_IGNORE_MAC;
2058         if (filter->flags & RTE_ETHTYPE_FLAGS_DROP)
2059                 flags |= I40E_AQC_ADD_CONTROL_PACKET_FLAGS_DROP;
2060         flags |= I40E_AQC_ADD_CONTROL_PACKET_FLAGS_TO_QUEUE;
2061
2062         memset(&stats, 0, sizeof(stats));
2063         ret = i40e_aq_add_rem_control_packet_filter(hw,
2064                                     filter->input.mac_addr.addr_bytes,
2065                                     filter->input.ether_type,
2066                                     flags, pf->main_vsi->seid,
2067                                     filter->queue, 0, &stats, NULL);
2068         if (ret < 0)
2069                 return ret;
2070
2071         node = i40e_sw_ethertype_filter_lookup(ethertype_rule, &filter->input);
2072         if (!node)
2073                 return -EINVAL;
2074
2075         ret = i40e_sw_ethertype_filter_del(pf, &node->input);
2076
2077         return ret;
2078 }
2079
2080 static int
2081 i40e_flow_destroy_tunnel_filter(struct i40e_pf *pf,
2082                                 struct i40e_tunnel_filter *filter)
2083 {
2084         struct i40e_hw *hw = I40E_PF_TO_HW(pf);
2085         struct i40e_vsi *vsi;
2086         struct i40e_pf_vf *vf;
2087         struct i40e_aqc_add_rm_cloud_filt_elem_ext cld_filter;
2088         struct i40e_tunnel_rule *tunnel_rule = &pf->tunnel;
2089         struct i40e_tunnel_filter *node;
2090         bool big_buffer = 0;
2091         int ret = 0;
2092
2093         memset(&cld_filter, 0, sizeof(cld_filter));
2094         ether_addr_copy((struct ether_addr *)&filter->input.outer_mac,
2095                         (struct ether_addr *)&cld_filter.element.outer_mac);
2096         ether_addr_copy((struct ether_addr *)&filter->input.inner_mac,
2097                         (struct ether_addr *)&cld_filter.element.inner_mac);
2098         cld_filter.element.inner_vlan = filter->input.inner_vlan;
2099         cld_filter.element.flags = filter->input.flags;
2100         cld_filter.element.tenant_id = filter->input.tenant_id;
2101         cld_filter.element.queue_number = filter->queue;
2102         rte_memcpy(cld_filter.general_fields,
2103                    filter->input.general_fields,
2104                    sizeof(cld_filter.general_fields));
2105
2106         if (!filter->is_to_vf)
2107                 vsi = pf->main_vsi;
2108         else {
2109                 vf = &pf->vfs[filter->vf_id];
2110                 vsi = vf->vsi;
2111         }
2112
2113         if (((filter->input.flags & I40E_AQC_ADD_CLOUD_FILTER_TEID_MPLSoUDP) ==
2114             I40E_AQC_ADD_CLOUD_FILTER_TEID_MPLSoUDP) ||
2115             ((filter->input.flags & I40E_AQC_ADD_CLOUD_FILTER_TEID_MPLSoGRE) ==
2116             I40E_AQC_ADD_CLOUD_FILTER_TEID_MPLSoGRE) ||
2117             ((filter->input.flags & I40E_AQC_ADD_CLOUD_FILTER_CUSTOM_QINQ) ==
2118             I40E_AQC_ADD_CLOUD_FILTER_CUSTOM_QINQ))
2119                 big_buffer = 1;
2120
2121         if (big_buffer)
2122                 ret = i40e_aq_remove_cloud_filters_big_buffer(hw, vsi->seid,
2123                                                               &cld_filter, 1);
2124         else
2125                 ret = i40e_aq_remove_cloud_filters(hw, vsi->seid,
2126                                                    &cld_filter.element, 1);
2127         if (ret < 0)
2128                 return -ENOTSUP;
2129
2130         node = i40e_sw_tunnel_filter_lookup(tunnel_rule, &filter->input);
2131         if (!node)
2132                 return -EINVAL;
2133
2134         ret = i40e_sw_tunnel_filter_del(pf, &node->input);
2135
2136         return ret;
2137 }
2138
2139 static int
2140 i40e_flow_flush(struct rte_eth_dev *dev, struct rte_flow_error *error)
2141 {
2142         struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
2143         int ret;
2144
2145         ret = i40e_flow_flush_fdir_filter(pf);
2146         if (ret) {
2147                 rte_flow_error_set(error, -ret,
2148                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
2149                                    "Failed to flush FDIR flows.");
2150                 return -rte_errno;
2151         }
2152
2153         ret = i40e_flow_flush_ethertype_filter(pf);
2154         if (ret) {
2155                 rte_flow_error_set(error, -ret,
2156                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
2157                                    "Failed to ethertype flush flows.");
2158                 return -rte_errno;
2159         }
2160
2161         ret = i40e_flow_flush_tunnel_filter(pf);
2162         if (ret) {
2163                 rte_flow_error_set(error, -ret,
2164                                    RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
2165                                    "Failed to flush tunnel flows.");
2166                 return -rte_errno;
2167         }
2168
2169         return ret;
2170 }
2171
2172 static int
2173 i40e_flow_flush_fdir_filter(struct i40e_pf *pf)
2174 {
2175         struct rte_eth_dev *dev = pf->adapter->eth_dev;
2176         struct i40e_fdir_info *fdir_info = &pf->fdir;
2177         struct i40e_fdir_filter *fdir_filter;
2178         struct rte_flow *flow;
2179         void *temp;
2180         int ret;
2181
2182         ret = i40e_fdir_flush(dev);
2183         if (!ret) {
2184                 /* Delete FDIR filters in FDIR list. */
2185                 while ((fdir_filter = TAILQ_FIRST(&fdir_info->fdir_list))) {
2186                         ret = i40e_sw_fdir_filter_del(pf,
2187                                                       &fdir_filter->fdir.input);
2188                         if (ret < 0)
2189                                 return ret;
2190                 }
2191
2192                 /* Delete FDIR flows in flow list. */
2193                 TAILQ_FOREACH_SAFE(flow, &pf->flow_list, node, temp) {
2194                         if (flow->filter_type == RTE_ETH_FILTER_FDIR) {
2195                                 TAILQ_REMOVE(&pf->flow_list, flow, node);
2196                                 rte_free(flow);
2197                         }
2198                 }
2199         }
2200
2201         return ret;
2202 }
2203
2204 /* Flush all ethertype filters */
2205 static int
2206 i40e_flow_flush_ethertype_filter(struct i40e_pf *pf)
2207 {
2208         struct i40e_ethertype_filter_list
2209                 *ethertype_list = &pf->ethertype.ethertype_list;
2210         struct i40e_ethertype_filter *filter;
2211         struct rte_flow *flow;
2212         void *temp;
2213         int ret = 0;
2214
2215         while ((filter = TAILQ_FIRST(ethertype_list))) {
2216                 ret = i40e_flow_destroy_ethertype_filter(pf, filter);
2217                 if (ret)
2218                         return ret;
2219         }
2220
2221         /* Delete ethertype flows in flow list. */
2222         TAILQ_FOREACH_SAFE(flow, &pf->flow_list, node, temp) {
2223                 if (flow->filter_type == RTE_ETH_FILTER_ETHERTYPE) {
2224                         TAILQ_REMOVE(&pf->flow_list, flow, node);
2225                         rte_free(flow);
2226                 }
2227         }
2228
2229         return ret;
2230 }
2231
2232 /* Flush all tunnel filters */
2233 static int
2234 i40e_flow_flush_tunnel_filter(struct i40e_pf *pf)
2235 {
2236         struct i40e_tunnel_filter_list
2237                 *tunnel_list = &pf->tunnel.tunnel_list;
2238         struct i40e_tunnel_filter *filter;
2239         struct rte_flow *flow;
2240         void *temp;
2241         int ret = 0;
2242
2243         while ((filter = TAILQ_FIRST(tunnel_list))) {
2244                 ret = i40e_flow_destroy_tunnel_filter(pf, filter);
2245                 if (ret)
2246                         return ret;
2247         }
2248
2249         /* Delete tunnel flows in flow list. */
2250         TAILQ_FOREACH_SAFE(flow, &pf->flow_list, node, temp) {
2251                 if (flow->filter_type == RTE_ETH_FILTER_TUNNEL) {
2252                         TAILQ_REMOVE(&pf->flow_list, flow, node);
2253                         rte_free(flow);
2254                 }
2255         }
2256
2257         return ret;
2258 }