net/mvpp2: use generic name for global config variable
[dpdk.git] / drivers / net / mvpp2 / mrvl_flow.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2018 Marvell International Ltd.
3  * Copyright(c) 2018 Semihalf.
4  * All rights reserved.
5  */
6
7 #include <rte_flow.h>
8 #include <rte_flow_driver.h>
9 #include <rte_malloc.h>
10 #include <rte_log.h>
11
12 #include <arpa/inet.h>
13
14 #include "mrvl_flow.h"
15 #include "mrvl_qos.h"
16
17 /** Number of rules in the classifier table. */
18 #define MRVL_CLS_MAX_NUM_RULES 20
19
20 /** Size of the classifier key and mask strings. */
21 #define MRVL_CLS_STR_SIZE_MAX 40
22
23 static const enum rte_flow_item_type pattern_eth[] = {
24         RTE_FLOW_ITEM_TYPE_ETH,
25         RTE_FLOW_ITEM_TYPE_END
26 };
27
28 static const enum rte_flow_item_type pattern_eth_vlan[] = {
29         RTE_FLOW_ITEM_TYPE_ETH,
30         RTE_FLOW_ITEM_TYPE_VLAN,
31         RTE_FLOW_ITEM_TYPE_END
32 };
33
34 static const enum rte_flow_item_type pattern_eth_vlan_ip[] = {
35         RTE_FLOW_ITEM_TYPE_ETH,
36         RTE_FLOW_ITEM_TYPE_VLAN,
37         RTE_FLOW_ITEM_TYPE_IPV4,
38         RTE_FLOW_ITEM_TYPE_END
39 };
40
41 static const enum rte_flow_item_type pattern_eth_vlan_ip6[] = {
42         RTE_FLOW_ITEM_TYPE_ETH,
43         RTE_FLOW_ITEM_TYPE_VLAN,
44         RTE_FLOW_ITEM_TYPE_IPV6,
45         RTE_FLOW_ITEM_TYPE_END
46 };
47
48 static const enum rte_flow_item_type pattern_eth_ip4[] = {
49         RTE_FLOW_ITEM_TYPE_ETH,
50         RTE_FLOW_ITEM_TYPE_IPV4,
51         RTE_FLOW_ITEM_TYPE_END
52 };
53
54 static const enum rte_flow_item_type pattern_eth_ip4_tcp[] = {
55         RTE_FLOW_ITEM_TYPE_ETH,
56         RTE_FLOW_ITEM_TYPE_IPV4,
57         RTE_FLOW_ITEM_TYPE_TCP,
58         RTE_FLOW_ITEM_TYPE_END
59 };
60
61 static const enum rte_flow_item_type pattern_eth_ip4_udp[] = {
62         RTE_FLOW_ITEM_TYPE_ETH,
63         RTE_FLOW_ITEM_TYPE_IPV4,
64         RTE_FLOW_ITEM_TYPE_UDP,
65         RTE_FLOW_ITEM_TYPE_END
66 };
67
68 static const enum rte_flow_item_type pattern_eth_ip6[] = {
69         RTE_FLOW_ITEM_TYPE_ETH,
70         RTE_FLOW_ITEM_TYPE_IPV6,
71         RTE_FLOW_ITEM_TYPE_END
72 };
73
74 static const enum rte_flow_item_type pattern_eth_ip6_tcp[] = {
75         RTE_FLOW_ITEM_TYPE_ETH,
76         RTE_FLOW_ITEM_TYPE_IPV6,
77         RTE_FLOW_ITEM_TYPE_TCP,
78         RTE_FLOW_ITEM_TYPE_END
79 };
80
81 static const enum rte_flow_item_type pattern_eth_ip6_udp[] = {
82         RTE_FLOW_ITEM_TYPE_ETH,
83         RTE_FLOW_ITEM_TYPE_IPV6,
84         RTE_FLOW_ITEM_TYPE_UDP,
85         RTE_FLOW_ITEM_TYPE_END
86 };
87
88 static const enum rte_flow_item_type pattern_vlan[] = {
89         RTE_FLOW_ITEM_TYPE_VLAN,
90         RTE_FLOW_ITEM_TYPE_END
91 };
92
93 static const enum rte_flow_item_type pattern_vlan_ip[] = {
94         RTE_FLOW_ITEM_TYPE_VLAN,
95         RTE_FLOW_ITEM_TYPE_IPV4,
96         RTE_FLOW_ITEM_TYPE_END
97 };
98
99 static const enum rte_flow_item_type pattern_vlan_ip_tcp[] = {
100         RTE_FLOW_ITEM_TYPE_VLAN,
101         RTE_FLOW_ITEM_TYPE_IPV4,
102         RTE_FLOW_ITEM_TYPE_TCP,
103         RTE_FLOW_ITEM_TYPE_END
104 };
105
106 static const enum rte_flow_item_type pattern_vlan_ip_udp[] = {
107         RTE_FLOW_ITEM_TYPE_VLAN,
108         RTE_FLOW_ITEM_TYPE_IPV4,
109         RTE_FLOW_ITEM_TYPE_UDP,
110         RTE_FLOW_ITEM_TYPE_END
111 };
112
113 static const enum rte_flow_item_type pattern_vlan_ip6[] = {
114         RTE_FLOW_ITEM_TYPE_VLAN,
115         RTE_FLOW_ITEM_TYPE_IPV6,
116         RTE_FLOW_ITEM_TYPE_END
117 };
118
119 static const enum rte_flow_item_type pattern_vlan_ip6_tcp[] = {
120         RTE_FLOW_ITEM_TYPE_VLAN,
121         RTE_FLOW_ITEM_TYPE_IPV6,
122         RTE_FLOW_ITEM_TYPE_TCP,
123         RTE_FLOW_ITEM_TYPE_END
124 };
125
126 static const enum rte_flow_item_type pattern_vlan_ip6_udp[] = {
127         RTE_FLOW_ITEM_TYPE_VLAN,
128         RTE_FLOW_ITEM_TYPE_IPV6,
129         RTE_FLOW_ITEM_TYPE_UDP,
130         RTE_FLOW_ITEM_TYPE_END
131 };
132
133 static const enum rte_flow_item_type pattern_ip[] = {
134         RTE_FLOW_ITEM_TYPE_IPV4,
135         RTE_FLOW_ITEM_TYPE_END
136 };
137
138 static const enum rte_flow_item_type pattern_ip6[] = {
139         RTE_FLOW_ITEM_TYPE_IPV6,
140         RTE_FLOW_ITEM_TYPE_END
141 };
142
143 static const enum rte_flow_item_type pattern_ip_tcp[] = {
144         RTE_FLOW_ITEM_TYPE_IPV4,
145         RTE_FLOW_ITEM_TYPE_TCP,
146         RTE_FLOW_ITEM_TYPE_END
147 };
148
149 static const enum rte_flow_item_type pattern_ip6_tcp[] = {
150         RTE_FLOW_ITEM_TYPE_IPV6,
151         RTE_FLOW_ITEM_TYPE_TCP,
152         RTE_FLOW_ITEM_TYPE_END
153 };
154
155 static const enum rte_flow_item_type pattern_ip_udp[] = {
156         RTE_FLOW_ITEM_TYPE_IPV4,
157         RTE_FLOW_ITEM_TYPE_UDP,
158         RTE_FLOW_ITEM_TYPE_END
159 };
160
161 static const enum rte_flow_item_type pattern_ip6_udp[] = {
162         RTE_FLOW_ITEM_TYPE_IPV6,
163         RTE_FLOW_ITEM_TYPE_UDP,
164         RTE_FLOW_ITEM_TYPE_END
165 };
166
167 static const enum rte_flow_item_type pattern_tcp[] = {
168         RTE_FLOW_ITEM_TYPE_TCP,
169         RTE_FLOW_ITEM_TYPE_END
170 };
171
172 static const enum rte_flow_item_type pattern_udp[] = {
173         RTE_FLOW_ITEM_TYPE_UDP,
174         RTE_FLOW_ITEM_TYPE_END
175 };
176
177 #define MRVL_VLAN_ID_MASK 0x0fff
178 #define MRVL_VLAN_PRI_MASK 0x7000
179 #define MRVL_IPV4_DSCP_MASK 0xfc
180 #define MRVL_IPV4_ADDR_MASK 0xffffffff
181 #define MRVL_IPV6_FLOW_MASK 0x0fffff
182
183 /**
184  * Given a flow item, return the next non-void one.
185  *
186  * @param items Pointer to the item in the table.
187  * @returns Next not-void item, NULL otherwise.
188  */
189 static const struct rte_flow_item *
190 mrvl_next_item(const struct rte_flow_item *items)
191 {
192         const struct rte_flow_item *item = items;
193
194         for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
195                 if (item->type != RTE_FLOW_ITEM_TYPE_VOID)
196                         return item;
197         }
198
199         return NULL;
200 }
201
202 /**
203  * Allocate memory for classifier rule key and mask fields.
204  *
205  * @param field Pointer to the classifier rule.
206  * @returns 0 in case of success, negative value otherwise.
207  */
208 static int
209 mrvl_alloc_key_mask(struct pp2_cls_rule_key_field *field)
210 {
211         unsigned int id = rte_socket_id();
212
213         field->key = rte_zmalloc_socket(NULL, MRVL_CLS_STR_SIZE_MAX, 0, id);
214         if (!field->key)
215                 goto out;
216
217         field->mask = rte_zmalloc_socket(NULL, MRVL_CLS_STR_SIZE_MAX, 0, id);
218         if (!field->mask)
219                 goto out_mask;
220
221         return 0;
222 out_mask:
223         rte_free(field->key);
224 out:
225         field->key = NULL;
226         field->mask = NULL;
227         return -1;
228 }
229
230 /**
231  * Free memory allocated for classifier rule key and mask fields.
232  *
233  * @param field Pointer to the classifier rule.
234  */
235 static void
236 mrvl_free_key_mask(struct pp2_cls_rule_key_field *field)
237 {
238         rte_free(field->key);
239         rte_free(field->mask);
240         field->key = NULL;
241         field->mask = NULL;
242 }
243
244 /**
245  * Free memory allocated for all classifier rule key and mask fields.
246  *
247  * @param rule Pointer to the classifier table rule.
248  */
249 static void
250 mrvl_free_all_key_mask(struct pp2_cls_tbl_rule *rule)
251 {
252         int i;
253
254         for (i = 0; i < rule->num_fields; i++)
255                 mrvl_free_key_mask(&rule->fields[i]);
256         rule->num_fields = 0;
257 }
258
259 /*
260  * Initialize rte flow item parsing.
261  *
262  * @param item Pointer to the flow item.
263  * @param spec_ptr Pointer to the specific item pointer.
264  * @param mask_ptr Pointer to the specific item's mask pointer.
265  * @def_mask Pointer to the default mask.
266  * @size Size of the flow item.
267  * @error Pointer to the rte flow error.
268  * @returns 0 in case of success, negative value otherwise.
269  */
270 static int
271 mrvl_parse_init(const struct rte_flow_item *item,
272                 const void **spec_ptr,
273                 const void **mask_ptr,
274                 const void *def_mask,
275                 unsigned int size,
276                 struct rte_flow_error *error)
277 {
278         const uint8_t *spec;
279         const uint8_t *mask;
280         const uint8_t *last;
281         uint8_t zeros[size];
282
283         memset(zeros, 0, size);
284
285         if (item == NULL) {
286                 rte_flow_error_set(error, EINVAL,
287                                    RTE_FLOW_ERROR_TYPE_ITEM, NULL,
288                                    "NULL item\n");
289                 return -rte_errno;
290         }
291
292         if ((item->last != NULL || item->mask != NULL) && item->spec == NULL) {
293                 rte_flow_error_set(error, EINVAL,
294                                    RTE_FLOW_ERROR_TYPE_ITEM, item,
295                                    "Mask or last is set without spec\n");
296                 return -rte_errno;
297         }
298
299         /*
300          * If "mask" is not set, default mask is used,
301          * but if default mask is NULL, "mask" should be set.
302          */
303         if (item->mask == NULL) {
304                 if (def_mask == NULL) {
305                         rte_flow_error_set(error, EINVAL,
306                                            RTE_FLOW_ERROR_TYPE_ITEM, NULL,
307                                            "Mask should be specified\n");
308                         return -rte_errno;
309                 }
310
311                 mask = (const uint8_t *)def_mask;
312         } else {
313                 mask = (const uint8_t *)item->mask;
314         }
315
316         spec = (const uint8_t *)item->spec;
317         last = (const uint8_t *)item->last;
318
319         if (spec == NULL) {
320                 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
321                                    NULL, "Spec should be specified\n");
322                 return -rte_errno;
323         }
324
325         /*
326          * If field values in "last" are either 0 or equal to the corresponding
327          * values in "spec" then they are ignored.
328          */
329         if (last != NULL &&
330             !memcmp(last, zeros, size) &&
331             memcmp(last, spec, size) != 0) {
332                 rte_flow_error_set(error, ENOTSUP,
333                                    RTE_FLOW_ERROR_TYPE_ITEM, NULL,
334                                    "Ranging is not supported\n");
335                 return -rte_errno;
336         }
337
338         *spec_ptr = spec;
339         *mask_ptr = mask;
340
341         return 0;
342 }
343
344 /**
345  * Parse the eth flow item.
346  *
347  * This will create classifier rule that matches either destination or source
348  * mac.
349  *
350  * @param spec Pointer to the specific flow item.
351  * @param mask Pointer to the specific flow item's mask.
352  * @param parse_dst Parse either destination or source mac address.
353  * @param flow Pointer to the flow.
354  * @return 0 in case of success, negative error value otherwise.
355  */
356 static int
357 mrvl_parse_mac(const struct rte_flow_item_eth *spec,
358                const struct rte_flow_item_eth *mask,
359                int parse_dst, struct rte_flow *flow)
360 {
361         struct pp2_cls_rule_key_field *key_field;
362         const uint8_t *k, *m;
363
364         if (flow->rule.num_fields >= PP2_CLS_TBL_MAX_NUM_FIELDS)
365                 return -ENOSPC;
366
367         if (parse_dst) {
368                 k = spec->dst.addr_bytes;
369                 m = mask->dst.addr_bytes;
370
371                 flow->pattern |= F_DMAC;
372         } else {
373                 k = spec->src.addr_bytes;
374                 m = mask->src.addr_bytes;
375
376                 flow->pattern |= F_SMAC;
377         }
378
379         key_field = &flow->rule.fields[flow->rule.num_fields];
380         mrvl_alloc_key_mask(key_field);
381         key_field->size = 6;
382
383         snprintf((char *)key_field->key, MRVL_CLS_STR_SIZE_MAX,
384                  "%02x:%02x:%02x:%02x:%02x:%02x",
385                  k[0], k[1], k[2], k[3], k[4], k[5]);
386
387         snprintf((char *)key_field->mask, MRVL_CLS_STR_SIZE_MAX,
388                  "%02x:%02x:%02x:%02x:%02x:%02x",
389                  m[0], m[1], m[2], m[3], m[4], m[5]);
390
391         flow->rule.num_fields += 1;
392
393         return 0;
394 }
395
396 /**
397  * Helper for parsing the eth flow item destination mac address.
398  *
399  * @param spec Pointer to the specific flow item.
400  * @param mask Pointer to the specific flow item's mask.
401  * @param flow Pointer to the flow.
402  * @return 0 in case of success, negative error value otherwise.
403  */
404 static inline int
405 mrvl_parse_dmac(const struct rte_flow_item_eth *spec,
406                 const struct rte_flow_item_eth *mask,
407                 struct rte_flow *flow)
408 {
409         return mrvl_parse_mac(spec, mask, 1, flow);
410 }
411
412 /**
413  * Helper for parsing the eth flow item source mac address.
414  *
415  * @param spec Pointer to the specific flow item.
416  * @param mask Pointer to the specific flow item's mask.
417  * @param flow Pointer to the flow.
418  * @return 0 in case of success, negative error value otherwise.
419  */
420 static inline int
421 mrvl_parse_smac(const struct rte_flow_item_eth *spec,
422                 const struct rte_flow_item_eth *mask,
423                 struct rte_flow *flow)
424 {
425         return mrvl_parse_mac(spec, mask, 0, flow);
426 }
427
428 /**
429  * Parse the ether type field of the eth flow item.
430  *
431  * @param spec Pointer to the specific flow item.
432  * @param mask Pointer to the specific flow item's mask.
433  * @param flow Pointer to the flow.
434  * @return 0 in case of success, negative error value otherwise.
435  */
436 static int
437 mrvl_parse_type(const struct rte_flow_item_eth *spec,
438                 const struct rte_flow_item_eth *mask __rte_unused,
439                 struct rte_flow *flow)
440 {
441         struct pp2_cls_rule_key_field *key_field;
442         uint16_t k;
443
444         if (flow->rule.num_fields >= PP2_CLS_TBL_MAX_NUM_FIELDS)
445                 return -ENOSPC;
446
447         key_field = &flow->rule.fields[flow->rule.num_fields];
448         mrvl_alloc_key_mask(key_field);
449         key_field->size = 2;
450
451         k = rte_be_to_cpu_16(spec->type);
452         snprintf((char *)key_field->key, MRVL_CLS_STR_SIZE_MAX, "%u", k);
453
454         flow->pattern |= F_TYPE;
455         flow->rule.num_fields += 1;
456
457         return 0;
458 }
459
460 /**
461  * Parse the vid field of the vlan rte flow item.
462  *
463  * This will create classifier rule that matches vid.
464  *
465  * @param spec Pointer to the specific flow item.
466  * @param mask Pointer to the specific flow item's mask.
467  * @param flow Pointer to the flow.
468  * @return 0 in case of success, negative error value otherwise.
469  */
470 static int
471 mrvl_parse_vlan_id(const struct rte_flow_item_vlan *spec,
472                    const struct rte_flow_item_vlan *mask __rte_unused,
473                    struct rte_flow *flow)
474 {
475         struct pp2_cls_rule_key_field *key_field;
476         uint16_t k;
477
478         if (flow->rule.num_fields >= PP2_CLS_TBL_MAX_NUM_FIELDS)
479                 return -ENOSPC;
480
481         key_field = &flow->rule.fields[flow->rule.num_fields];
482         mrvl_alloc_key_mask(key_field);
483         key_field->size = 2;
484
485         k = rte_be_to_cpu_16(spec->tci) & MRVL_VLAN_ID_MASK;
486         snprintf((char *)key_field->key, MRVL_CLS_STR_SIZE_MAX, "%u", k);
487
488         flow->pattern |= F_VLAN_ID;
489         flow->rule.num_fields += 1;
490
491         return 0;
492 }
493
494 /**
495  * Parse the pri field of the vlan rte flow item.
496  *
497  * This will create classifier rule that matches pri.
498  *
499  * @param spec Pointer to the specific flow item.
500  * @param mask Pointer to the specific flow item's mask.
501  * @param flow Pointer to the flow.
502  * @return 0 in case of success, negative error value otherwise.
503  */
504 static int
505 mrvl_parse_vlan_pri(const struct rte_flow_item_vlan *spec,
506                     const struct rte_flow_item_vlan *mask __rte_unused,
507                     struct rte_flow *flow)
508 {
509         struct pp2_cls_rule_key_field *key_field;
510         uint16_t k;
511
512         if (flow->rule.num_fields >= PP2_CLS_TBL_MAX_NUM_FIELDS)
513                 return -ENOSPC;
514
515         key_field = &flow->rule.fields[flow->rule.num_fields];
516         mrvl_alloc_key_mask(key_field);
517         key_field->size = 1;
518
519         k = (rte_be_to_cpu_16(spec->tci) & MRVL_VLAN_PRI_MASK) >> 13;
520         snprintf((char *)key_field->key, MRVL_CLS_STR_SIZE_MAX, "%u", k);
521
522         flow->pattern |= F_VLAN_PRI;
523         flow->rule.num_fields += 1;
524
525         return 0;
526 }
527
528 /**
529  * Parse the dscp field of the ipv4 rte flow item.
530  *
531  * This will create classifier rule that matches dscp field.
532  *
533  * @param spec Pointer to the specific flow item.
534  * @param mask Pointer to the specific flow item's mask.
535  * @param flow Pointer to the flow.
536  * @return 0 in case of success, negative error value otherwise.
537  */
538 static int
539 mrvl_parse_ip4_dscp(const struct rte_flow_item_ipv4 *spec,
540                     const struct rte_flow_item_ipv4 *mask,
541                     struct rte_flow *flow)
542 {
543         struct pp2_cls_rule_key_field *key_field;
544         uint8_t k, m;
545
546         if (flow->rule.num_fields >= PP2_CLS_TBL_MAX_NUM_FIELDS)
547                 return -ENOSPC;
548
549         key_field = &flow->rule.fields[flow->rule.num_fields];
550         mrvl_alloc_key_mask(key_field);
551         key_field->size = 1;
552
553         k = (spec->hdr.type_of_service & MRVL_IPV4_DSCP_MASK) >> 2;
554         m = (mask->hdr.type_of_service & MRVL_IPV4_DSCP_MASK) >> 2;
555         snprintf((char *)key_field->key, MRVL_CLS_STR_SIZE_MAX, "%u", k);
556         snprintf((char *)key_field->mask, MRVL_CLS_STR_SIZE_MAX, "%u", m);
557
558         flow->pattern |= F_IP4_TOS;
559         flow->rule.num_fields += 1;
560
561         return 0;
562 }
563
564 /**
565  * Parse either source or destination ip addresses of the ipv4 flow item.
566  *
567  * This will create classifier rule that matches either destination
568  * or source ip field.
569  *
570  * @param spec Pointer to the specific flow item.
571  * @param mask Pointer to the specific flow item's mask.
572  * @param parse_dst Parse either destination or source ip address.
573  * @param flow Pointer to the flow.
574  * @return 0 in case of success, negative error value otherwise.
575  */
576 static int
577 mrvl_parse_ip4_addr(const struct rte_flow_item_ipv4 *spec,
578                     const struct rte_flow_item_ipv4 *mask,
579                     int parse_dst, struct rte_flow *flow)
580 {
581         struct pp2_cls_rule_key_field *key_field;
582         struct in_addr k;
583         uint32_t m;
584
585         if (flow->rule.num_fields >= PP2_CLS_TBL_MAX_NUM_FIELDS)
586                 return -ENOSPC;
587
588         memset(&k, 0, sizeof(k));
589         if (parse_dst) {
590                 k.s_addr = spec->hdr.dst_addr;
591                 m = rte_be_to_cpu_32(mask->hdr.dst_addr);
592
593                 flow->pattern |= F_IP4_DIP;
594         } else {
595                 k.s_addr = spec->hdr.src_addr;
596                 m = rte_be_to_cpu_32(mask->hdr.src_addr);
597
598                 flow->pattern |= F_IP4_SIP;
599         }
600
601         key_field = &flow->rule.fields[flow->rule.num_fields];
602         mrvl_alloc_key_mask(key_field);
603         key_field->size = 4;
604
605         inet_ntop(AF_INET, &k, (char *)key_field->key, MRVL_CLS_STR_SIZE_MAX);
606         snprintf((char *)key_field->mask, MRVL_CLS_STR_SIZE_MAX, "0x%x", m);
607
608         flow->rule.num_fields += 1;
609
610         return 0;
611 }
612
613 /**
614  * Helper for parsing destination ip of the ipv4 flow item.
615  *
616  * @param spec Pointer to the specific flow item.
617  * @param mask Pointer to the specific flow item's mask.
618  * @param flow Pointer to the flow.
619  * @return 0 in case of success, negative error value otherwise.
620  */
621 static inline int
622 mrvl_parse_ip4_dip(const struct rte_flow_item_ipv4 *spec,
623                    const struct rte_flow_item_ipv4 *mask,
624                    struct rte_flow *flow)
625 {
626         return mrvl_parse_ip4_addr(spec, mask, 1, flow);
627 }
628
629 /**
630  * Helper for parsing source ip of the ipv4 flow item.
631  *
632  * @param spec Pointer to the specific flow item.
633  * @param mask Pointer to the specific flow item's mask.
634  * @param flow Pointer to the flow.
635  * @return 0 in case of success, negative error value otherwise.
636  */
637 static inline int
638 mrvl_parse_ip4_sip(const struct rte_flow_item_ipv4 *spec,
639                    const struct rte_flow_item_ipv4 *mask,
640                    struct rte_flow *flow)
641 {
642         return mrvl_parse_ip4_addr(spec, mask, 0, flow);
643 }
644
645 /**
646  * Parse the proto field of the ipv4 rte flow item.
647  *
648  * This will create classifier rule that matches proto field.
649  *
650  * @param spec Pointer to the specific flow item.
651  * @param mask Pointer to the specific flow item's mask.
652  * @param flow Pointer to the flow.
653  * @return 0 in case of success, negative error value otherwise.
654  */
655 static int
656 mrvl_parse_ip4_proto(const struct rte_flow_item_ipv4 *spec,
657                      const struct rte_flow_item_ipv4 *mask __rte_unused,
658                      struct rte_flow *flow)
659 {
660         struct pp2_cls_rule_key_field *key_field;
661         uint8_t k = spec->hdr.next_proto_id;
662
663         if (flow->rule.num_fields >= PP2_CLS_TBL_MAX_NUM_FIELDS)
664                 return -ENOSPC;
665
666         key_field = &flow->rule.fields[flow->rule.num_fields];
667         mrvl_alloc_key_mask(key_field);
668         key_field->size = 1;
669
670         snprintf((char *)key_field->key, MRVL_CLS_STR_SIZE_MAX, "%u", k);
671
672         flow->pattern |= F_IP4_PROTO;
673         flow->rule.num_fields += 1;
674
675         return 0;
676 }
677
678 /**
679  * Parse either source or destination ip addresses of the ipv6 rte flow item.
680  *
681  * This will create classifier rule that matches either destination
682  * or source ip field.
683  *
684  * @param spec Pointer to the specific flow item.
685  * @param mask Pointer to the specific flow item's mask.
686  * @param parse_dst Parse either destination or source ipv6 address.
687  * @param flow Pointer to the flow.
688  * @return 0 in case of success, negative error value otherwise.
689  */
690 static int
691 mrvl_parse_ip6_addr(const struct rte_flow_item_ipv6 *spec,
692                const struct rte_flow_item_ipv6 *mask,
693                int parse_dst, struct rte_flow *flow)
694 {
695         struct pp2_cls_rule_key_field *key_field;
696         int size = sizeof(spec->hdr.dst_addr);
697         struct in6_addr k, m;
698
699         if (flow->rule.num_fields >= PP2_CLS_TBL_MAX_NUM_FIELDS)
700                 return -ENOSPC;
701
702         memset(&k, 0, sizeof(k));
703         if (parse_dst) {
704                 memcpy(k.s6_addr, spec->hdr.dst_addr, size);
705                 memcpy(m.s6_addr, mask->hdr.dst_addr, size);
706
707                 flow->pattern |= F_IP6_DIP;
708         } else {
709                 memcpy(k.s6_addr, spec->hdr.src_addr, size);
710                 memcpy(m.s6_addr, mask->hdr.src_addr, size);
711
712                 flow->pattern |= F_IP6_SIP;
713         }
714
715         key_field = &flow->rule.fields[flow->rule.num_fields];
716         mrvl_alloc_key_mask(key_field);
717         key_field->size = 16;
718
719         inet_ntop(AF_INET6, &k, (char *)key_field->key, MRVL_CLS_STR_SIZE_MAX);
720         inet_ntop(AF_INET6, &m, (char *)key_field->mask, MRVL_CLS_STR_SIZE_MAX);
721
722         flow->rule.num_fields += 1;
723
724         return 0;
725 }
726
727 /**
728  * Helper for parsing destination ip of the ipv6 flow item.
729  *
730  * @param spec Pointer to the specific flow item.
731  * @param mask Pointer to the specific flow item's mask.
732  * @param flow Pointer to the flow.
733  * @return 0 in case of success, negative error value otherwise.
734  */
735 static inline int
736 mrvl_parse_ip6_dip(const struct rte_flow_item_ipv6 *spec,
737                    const struct rte_flow_item_ipv6 *mask,
738                    struct rte_flow *flow)
739 {
740         return mrvl_parse_ip6_addr(spec, mask, 1, flow);
741 }
742
743 /**
744  * Helper for parsing source ip of the ipv6 flow item.
745  *
746  * @param spec Pointer to the specific flow item.
747  * @param mask Pointer to the specific flow item's mask.
748  * @param flow Pointer to the flow.
749  * @return 0 in case of success, negative error value otherwise.
750  */
751 static inline int
752 mrvl_parse_ip6_sip(const struct rte_flow_item_ipv6 *spec,
753                    const struct rte_flow_item_ipv6 *mask,
754                    struct rte_flow *flow)
755 {
756         return mrvl_parse_ip6_addr(spec, mask, 0, flow);
757 }
758
759 /**
760  * Parse the flow label of the ipv6 flow item.
761  *
762  * This will create classifier rule that matches flow field.
763  *
764  * @param spec Pointer to the specific flow item.
765  * @param mask Pointer to the specific flow item's mask.
766  * @param flow Pointer to the flow.
767  * @return 0 in case of success, negative error value otherwise.
768  */
769 static int
770 mrvl_parse_ip6_flow(const struct rte_flow_item_ipv6 *spec,
771                     const struct rte_flow_item_ipv6 *mask,
772                     struct rte_flow *flow)
773 {
774         struct pp2_cls_rule_key_field *key_field;
775         uint32_t k = rte_be_to_cpu_32(spec->hdr.vtc_flow) & MRVL_IPV6_FLOW_MASK,
776                  m = rte_be_to_cpu_32(mask->hdr.vtc_flow) & MRVL_IPV6_FLOW_MASK;
777
778         if (flow->rule.num_fields >= PP2_CLS_TBL_MAX_NUM_FIELDS)
779                 return -ENOSPC;
780
781         key_field = &flow->rule.fields[flow->rule.num_fields];
782         mrvl_alloc_key_mask(key_field);
783         key_field->size = 3;
784
785         snprintf((char *)key_field->key, MRVL_CLS_STR_SIZE_MAX, "%u", k);
786         snprintf((char *)key_field->mask, MRVL_CLS_STR_SIZE_MAX, "%u", m);
787
788         flow->pattern |= F_IP6_FLOW;
789         flow->rule.num_fields += 1;
790
791         return 0;
792 }
793
794 /**
795  * Parse the next header of the ipv6 flow item.
796  *
797  * This will create classifier rule that matches next header field.
798  *
799  * @param spec Pointer to the specific flow item.
800  * @param mask Pointer to the specific flow item's mask.
801  * @param flow Pointer to the flow.
802  * @return 0 in case of success, negative error value otherwise.
803  */
804 static int
805 mrvl_parse_ip6_next_hdr(const struct rte_flow_item_ipv6 *spec,
806                         const struct rte_flow_item_ipv6 *mask __rte_unused,
807                         struct rte_flow *flow)
808 {
809         struct pp2_cls_rule_key_field *key_field;
810         uint8_t k = spec->hdr.proto;
811
812         if (flow->rule.num_fields >= PP2_CLS_TBL_MAX_NUM_FIELDS)
813                 return -ENOSPC;
814
815         key_field = &flow->rule.fields[flow->rule.num_fields];
816         mrvl_alloc_key_mask(key_field);
817         key_field->size = 1;
818
819         snprintf((char *)key_field->key, MRVL_CLS_STR_SIZE_MAX, "%u", k);
820
821         flow->pattern |= F_IP6_NEXT_HDR;
822         flow->rule.num_fields += 1;
823
824         return 0;
825 }
826
827 /**
828  * Parse destination or source port of the tcp flow item.
829  *
830  * This will create classifier rule that matches either destination or
831  * source tcp port.
832  *
833  * @param spec Pointer to the specific flow item.
834  * @param mask Pointer to the specific flow item's mask.
835  * @param parse_dst Parse either destination or source port.
836  * @param flow Pointer to the flow.
837  * @return 0 in case of success, negative error value otherwise.
838  */
839 static int
840 mrvl_parse_tcp_port(const struct rte_flow_item_tcp *spec,
841                     const struct rte_flow_item_tcp *mask __rte_unused,
842                     int parse_dst, struct rte_flow *flow)
843 {
844         struct pp2_cls_rule_key_field *key_field;
845         uint16_t k;
846
847         if (flow->rule.num_fields >= PP2_CLS_TBL_MAX_NUM_FIELDS)
848                 return -ENOSPC;
849
850         key_field = &flow->rule.fields[flow->rule.num_fields];
851         mrvl_alloc_key_mask(key_field);
852         key_field->size = 2;
853
854         if (parse_dst) {
855                 k = rte_be_to_cpu_16(spec->hdr.dst_port);
856
857                 flow->pattern |= F_TCP_DPORT;
858         } else {
859                 k = rte_be_to_cpu_16(spec->hdr.src_port);
860
861                 flow->pattern |= F_TCP_SPORT;
862         }
863
864         snprintf((char *)key_field->key, MRVL_CLS_STR_SIZE_MAX, "%u", k);
865
866         flow->rule.num_fields += 1;
867
868         return 0;
869 }
870
871 /**
872  * Helper for parsing the tcp source port of the tcp flow item.
873  *
874  * @param spec Pointer to the specific flow item.
875  * @param mask Pointer to the specific flow item's mask.
876  * @param flow Pointer to the flow.
877  * @return 0 in case of success, negative error value otherwise.
878  */
879 static inline int
880 mrvl_parse_tcp_sport(const struct rte_flow_item_tcp *spec,
881                      const struct rte_flow_item_tcp *mask,
882                      struct rte_flow *flow)
883 {
884         return mrvl_parse_tcp_port(spec, mask, 0, flow);
885 }
886
887 /**
888  * Helper for parsing the tcp destination port of the tcp flow item.
889  *
890  * @param spec Pointer to the specific flow item.
891  * @param mask Pointer to the specific flow item's mask.
892  * @param flow Pointer to the flow.
893  * @return 0 in case of success, negative error value otherwise.
894  */
895 static inline int
896 mrvl_parse_tcp_dport(const struct rte_flow_item_tcp *spec,
897                      const struct rte_flow_item_tcp *mask,
898                      struct rte_flow *flow)
899 {
900         return mrvl_parse_tcp_port(spec, mask, 1, flow);
901 }
902
903 /**
904  * Parse destination or source port of the udp flow item.
905  *
906  * This will create classifier rule that matches either destination or
907  * source udp port.
908  *
909  * @param spec Pointer to the specific flow item.
910  * @param mask Pointer to the specific flow item's mask.
911  * @param parse_dst Parse either destination or source port.
912  * @param flow Pointer to the flow.
913  * @return 0 in case of success, negative error value otherwise.
914  */
915 static int
916 mrvl_parse_udp_port(const struct rte_flow_item_udp *spec,
917                     const struct rte_flow_item_udp *mask __rte_unused,
918                     int parse_dst, struct rte_flow *flow)
919 {
920         struct pp2_cls_rule_key_field *key_field;
921         uint16_t k;
922
923         if (flow->rule.num_fields >= PP2_CLS_TBL_MAX_NUM_FIELDS)
924                 return -ENOSPC;
925
926         key_field = &flow->rule.fields[flow->rule.num_fields];
927         mrvl_alloc_key_mask(key_field);
928         key_field->size = 2;
929
930         if (parse_dst) {
931                 k = rte_be_to_cpu_16(spec->hdr.dst_port);
932
933                 flow->pattern |= F_UDP_DPORT;
934         } else {
935                 k = rte_be_to_cpu_16(spec->hdr.src_port);
936
937                 flow->pattern |= F_UDP_SPORT;
938         }
939
940         snprintf((char *)key_field->key, MRVL_CLS_STR_SIZE_MAX, "%u", k);
941
942         flow->rule.num_fields += 1;
943
944         return 0;
945 }
946
947 /**
948  * Helper for parsing the udp source port of the udp flow item.
949  *
950  * @param spec Pointer to the specific flow item.
951  * @param mask Pointer to the specific flow item's mask.
952  * @param flow Pointer to the flow.
953  * @return 0 in case of success, negative error value otherwise.
954  */
955 static inline int
956 mrvl_parse_udp_sport(const struct rte_flow_item_udp *spec,
957                      const struct rte_flow_item_udp *mask,
958                      struct rte_flow *flow)
959 {
960         return mrvl_parse_udp_port(spec, mask, 0, flow);
961 }
962
963 /**
964  * Helper for parsing the udp destination port of the udp flow item.
965  *
966  * @param spec Pointer to the specific flow item.
967  * @param mask Pointer to the specific flow item's mask.
968  * @param flow Pointer to the flow.
969  * @return 0 in case of success, negative error value otherwise.
970  */
971 static inline int
972 mrvl_parse_udp_dport(const struct rte_flow_item_udp *spec,
973                      const struct rte_flow_item_udp *mask,
974                      struct rte_flow *flow)
975 {
976         return mrvl_parse_udp_port(spec, mask, 1, flow);
977 }
978
979 /**
980  * Parse eth flow item.
981  *
982  * @param item Pointer to the flow item.
983  * @param flow Pointer to the flow.
984  * @param error Pointer to the flow error.
985  * @returns 0 on success, negative value otherwise.
986  */
987 static int
988 mrvl_parse_eth(const struct rte_flow_item *item, struct rte_flow *flow,
989                struct rte_flow_error *error)
990 {
991         const struct rte_flow_item_eth *spec = NULL, *mask = NULL;
992         struct rte_ether_addr zero;
993         int ret;
994
995         ret = mrvl_parse_init(item, (const void **)&spec, (const void **)&mask,
996                               &rte_flow_item_eth_mask,
997                               sizeof(struct rte_flow_item_eth), error);
998         if (ret)
999                 return ret;
1000
1001         memset(&zero, 0, sizeof(zero));
1002
1003         if (memcmp(&mask->dst, &zero, sizeof(mask->dst))) {
1004                 ret = mrvl_parse_dmac(spec, mask, flow);
1005                 if (ret)
1006                         goto out;
1007         }
1008
1009         if (memcmp(&mask->src, &zero, sizeof(mask->src))) {
1010                 ret = mrvl_parse_smac(spec, mask, flow);
1011                 if (ret)
1012                         goto out;
1013         }
1014
1015         if (mask->type) {
1016                 MRVL_LOG(WARNING, "eth type mask is ignored");
1017                 ret = mrvl_parse_type(spec, mask, flow);
1018                 if (ret)
1019                         goto out;
1020         }
1021
1022         return 0;
1023 out:
1024         rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
1025                            "Reached maximum number of fields in cls tbl key\n");
1026         return -rte_errno;
1027 }
1028
1029 /**
1030  * Parse vlan flow item.
1031  *
1032  * @param item Pointer to the flow item.
1033  * @param flow Pointer to the flow.
1034  * @param error Pointer to the flow error.
1035  * @returns 0 on success, negative value otherwise.
1036  */
1037 static int
1038 mrvl_parse_vlan(const struct rte_flow_item *item,
1039                 struct rte_flow *flow,
1040                 struct rte_flow_error *error)
1041 {
1042         const struct rte_flow_item_vlan *spec = NULL, *mask = NULL;
1043         uint16_t m;
1044         int ret;
1045
1046         ret = mrvl_parse_init(item, (const void **)&spec, (const void **)&mask,
1047                               &rte_flow_item_vlan_mask,
1048                               sizeof(struct rte_flow_item_vlan), error);
1049         if (ret)
1050                 return ret;
1051
1052         m = rte_be_to_cpu_16(mask->tci);
1053         if (m & MRVL_VLAN_ID_MASK) {
1054                 MRVL_LOG(WARNING, "vlan id mask is ignored");
1055                 ret = mrvl_parse_vlan_id(spec, mask, flow);
1056                 if (ret)
1057                         goto out;
1058         }
1059
1060         if (m & MRVL_VLAN_PRI_MASK) {
1061                 MRVL_LOG(WARNING, "vlan pri mask is ignored");
1062                 ret = mrvl_parse_vlan_pri(spec, mask, flow);
1063                 if (ret)
1064                         goto out;
1065         }
1066
1067         if (flow->pattern & F_TYPE) {
1068                 rte_flow_error_set(error, ENOTSUP,
1069                                    RTE_FLOW_ERROR_TYPE_ITEM, item,
1070                                    "VLAN TPID matching is not supported");
1071                 return -rte_errno;
1072         }
1073         if (mask->inner_type) {
1074                 struct rte_flow_item_eth spec_eth = {
1075                         .type = spec->inner_type,
1076                 };
1077                 struct rte_flow_item_eth mask_eth = {
1078                         .type = mask->inner_type,
1079                 };
1080
1081                 MRVL_LOG(WARNING, "inner eth type mask is ignored");
1082                 ret = mrvl_parse_type(&spec_eth, &mask_eth, flow);
1083                 if (ret)
1084                         goto out;
1085         }
1086
1087         return 0;
1088 out:
1089         rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
1090                            "Reached maximum number of fields in cls tbl key\n");
1091         return -rte_errno;
1092 }
1093
1094 /**
1095  * Parse ipv4 flow item.
1096  *
1097  * @param item Pointer to the flow item.
1098  * @param flow Pointer to the flow.
1099  * @param error Pointer to the flow error.
1100  * @returns 0 on success, negative value otherwise.
1101  */
1102 static int
1103 mrvl_parse_ip4(const struct rte_flow_item *item,
1104                struct rte_flow *flow,
1105                struct rte_flow_error *error)
1106 {
1107         const struct rte_flow_item_ipv4 *spec = NULL, *mask = NULL;
1108         int ret;
1109
1110         ret = mrvl_parse_init(item, (const void **)&spec, (const void **)&mask,
1111                               &rte_flow_item_ipv4_mask,
1112                               sizeof(struct rte_flow_item_ipv4), error);
1113         if (ret)
1114                 return ret;
1115
1116         if (mask->hdr.version_ihl ||
1117             mask->hdr.total_length ||
1118             mask->hdr.packet_id ||
1119             mask->hdr.fragment_offset ||
1120             mask->hdr.time_to_live ||
1121             mask->hdr.hdr_checksum) {
1122                 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
1123                                    NULL, "Not supported by classifier\n");
1124                 return -rte_errno;
1125         }
1126
1127         if (mask->hdr.type_of_service & MRVL_IPV4_DSCP_MASK) {
1128                 ret = mrvl_parse_ip4_dscp(spec, mask, flow);
1129                 if (ret)
1130                         goto out;
1131         }
1132
1133         if (mask->hdr.src_addr) {
1134                 ret = mrvl_parse_ip4_sip(spec, mask, flow);
1135                 if (ret)
1136                         goto out;
1137         }
1138
1139         if (mask->hdr.dst_addr) {
1140                 ret = mrvl_parse_ip4_dip(spec, mask, flow);
1141                 if (ret)
1142                         goto out;
1143         }
1144
1145         if (mask->hdr.next_proto_id) {
1146                 MRVL_LOG(WARNING, "next proto id mask is ignored");
1147                 ret = mrvl_parse_ip4_proto(spec, mask, flow);
1148                 if (ret)
1149                         goto out;
1150         }
1151
1152         return 0;
1153 out:
1154         rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
1155                            "Reached maximum number of fields in cls tbl key\n");
1156         return -rte_errno;
1157 }
1158
1159 /**
1160  * Parse ipv6 flow item.
1161  *
1162  * @param item Pointer to the flow item.
1163  * @param flow Pointer to the flow.
1164  * @param error Pointer to the flow error.
1165  * @returns 0 on success, negative value otherwise.
1166  */
1167 static int
1168 mrvl_parse_ip6(const struct rte_flow_item *item,
1169                struct rte_flow *flow,
1170                struct rte_flow_error *error)
1171 {
1172         const struct rte_flow_item_ipv6 *spec = NULL, *mask = NULL;
1173         struct rte_ipv6_hdr zero;
1174         uint32_t flow_mask;
1175         int ret;
1176
1177         ret = mrvl_parse_init(item, (const void **)&spec,
1178                               (const void **)&mask,
1179                               &rte_flow_item_ipv6_mask,
1180                               sizeof(struct rte_flow_item_ipv6),
1181                               error);
1182         if (ret)
1183                 return ret;
1184
1185         memset(&zero, 0, sizeof(zero));
1186
1187         if (mask->hdr.payload_len ||
1188             mask->hdr.hop_limits) {
1189                 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
1190                                    NULL, "Not supported by classifier\n");
1191                 return -rte_errno;
1192         }
1193
1194         if (memcmp(mask->hdr.src_addr,
1195                    zero.src_addr, sizeof(mask->hdr.src_addr))) {
1196                 ret = mrvl_parse_ip6_sip(spec, mask, flow);
1197                 if (ret)
1198                         goto out;
1199         }
1200
1201         if (memcmp(mask->hdr.dst_addr,
1202                    zero.dst_addr, sizeof(mask->hdr.dst_addr))) {
1203                 ret = mrvl_parse_ip6_dip(spec, mask, flow);
1204                 if (ret)
1205                         goto out;
1206         }
1207
1208         flow_mask = rte_be_to_cpu_32(mask->hdr.vtc_flow) & MRVL_IPV6_FLOW_MASK;
1209         if (flow_mask) {
1210                 ret = mrvl_parse_ip6_flow(spec, mask, flow);
1211                 if (ret)
1212                         goto out;
1213         }
1214
1215         if (mask->hdr.proto) {
1216                 MRVL_LOG(WARNING, "next header mask is ignored");
1217                 ret = mrvl_parse_ip6_next_hdr(spec, mask, flow);
1218                 if (ret)
1219                         goto out;
1220         }
1221
1222         return 0;
1223 out:
1224         rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
1225                            "Reached maximum number of fields in cls tbl key\n");
1226         return -rte_errno;
1227 }
1228
1229 /**
1230  * Parse tcp flow item.
1231  *
1232  * @param item Pointer to the flow item.
1233  * @param flow Pointer to the flow.
1234  * @param error Pointer to the flow error.
1235  * @returns 0 on success, negative value otherwise.
1236  */
1237 static int
1238 mrvl_parse_tcp(const struct rte_flow_item *item,
1239                struct rte_flow *flow,
1240                struct rte_flow_error *error)
1241 {
1242         const struct rte_flow_item_tcp *spec = NULL, *mask = NULL;
1243         int ret;
1244
1245         ret = mrvl_parse_init(item, (const void **)&spec, (const void **)&mask,
1246                               &rte_flow_item_ipv4_mask,
1247                               sizeof(struct rte_flow_item_ipv4), error);
1248         if (ret)
1249                 return ret;
1250
1251         if (mask->hdr.sent_seq ||
1252             mask->hdr.recv_ack ||
1253             mask->hdr.data_off ||
1254             mask->hdr.tcp_flags ||
1255             mask->hdr.rx_win ||
1256             mask->hdr.cksum ||
1257             mask->hdr.tcp_urp) {
1258                 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
1259                                    NULL, "Not supported by classifier\n");
1260                 return -rte_errno;
1261         }
1262
1263         if (mask->hdr.src_port) {
1264                 MRVL_LOG(WARNING, "tcp sport mask is ignored");
1265                 ret = mrvl_parse_tcp_sport(spec, mask, flow);
1266                 if (ret)
1267                         goto out;
1268         }
1269
1270         if (mask->hdr.dst_port) {
1271                 MRVL_LOG(WARNING, "tcp dport mask is ignored");
1272                 ret = mrvl_parse_tcp_dport(spec, mask, flow);
1273                 if (ret)
1274                         goto out;
1275         }
1276
1277         return 0;
1278 out:
1279         rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
1280                            "Reached maximum number of fields in cls tbl key\n");
1281         return -rte_errno;
1282 }
1283
1284 /**
1285  * Parse udp flow item.
1286  *
1287  * @param item Pointer to the flow item.
1288  * @param flow Pointer to the flow.
1289  * @param error Pointer to the flow error.
1290  * @returns 0 on success, negative value otherwise.
1291  */
1292 static int
1293 mrvl_parse_udp(const struct rte_flow_item *item,
1294                struct rte_flow *flow,
1295                struct rte_flow_error *error)
1296 {
1297         const struct rte_flow_item_udp *spec = NULL, *mask = NULL;
1298         int ret;
1299
1300         ret = mrvl_parse_init(item, (const void **)&spec, (const void **)&mask,
1301                               &rte_flow_item_ipv4_mask,
1302                               sizeof(struct rte_flow_item_ipv4), error);
1303         if (ret)
1304                 return ret;
1305
1306         if (mask->hdr.dgram_len ||
1307             mask->hdr.dgram_cksum) {
1308                 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
1309                                    NULL, "Not supported by classifier\n");
1310                 return -rte_errno;
1311         }
1312
1313         if (mask->hdr.src_port) {
1314                 MRVL_LOG(WARNING, "udp sport mask is ignored");
1315                 ret = mrvl_parse_udp_sport(spec, mask, flow);
1316                 if (ret)
1317                         goto out;
1318         }
1319
1320         if (mask->hdr.dst_port) {
1321                 MRVL_LOG(WARNING, "udp dport mask is ignored");
1322                 ret = mrvl_parse_udp_dport(spec, mask, flow);
1323                 if (ret)
1324                         goto out;
1325         }
1326
1327         return 0;
1328 out:
1329         rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
1330                            "Reached maximum number of fields in cls tbl key\n");
1331         return -rte_errno;
1332 }
1333
1334 /**
1335  * Parse flow pattern composed of the the eth item.
1336  *
1337  * @param pattern Pointer to the flow pattern table.
1338  * @param flow Pointer to the flow.
1339  * @param error Pointer to the flow error.
1340  * @returns 0 in case of success, negative value otherwise.
1341  */
1342 static int
1343 mrvl_parse_pattern_eth(const struct rte_flow_item pattern[],
1344                        struct rte_flow *flow,
1345                        struct rte_flow_error *error)
1346 {
1347         return mrvl_parse_eth(pattern, flow, error);
1348 }
1349
1350 /**
1351  * Parse flow pattern composed of the eth and vlan items.
1352  *
1353  * @param pattern Pointer to the flow pattern table.
1354  * @param flow Pointer to the flow.
1355  * @param error Pointer to the flow error.
1356  * @returns 0 in case of success, negative value otherwise.
1357  */
1358 static int
1359 mrvl_parse_pattern_eth_vlan(const struct rte_flow_item pattern[],
1360                             struct rte_flow *flow,
1361                             struct rte_flow_error *error)
1362 {
1363         const struct rte_flow_item *item = mrvl_next_item(pattern);
1364         int ret;
1365
1366         ret = mrvl_parse_eth(item, flow, error);
1367         if (ret)
1368                 return ret;
1369
1370         item = mrvl_next_item(item + 1);
1371
1372         return mrvl_parse_vlan(item, flow, error);
1373 }
1374
1375 /**
1376  * Parse flow pattern composed of the eth, vlan and ip4/ip6 items.
1377  *
1378  * @param pattern Pointer to the flow pattern table.
1379  * @param flow Pointer to the flow.
1380  * @param error Pointer to the flow error.
1381  * @param ip6 1 to parse ip6 item, 0 to parse ip4 item.
1382  * @returns 0 in case of success, negative value otherwise.
1383  */
1384 static int
1385 mrvl_parse_pattern_eth_vlan_ip4_ip6(const struct rte_flow_item pattern[],
1386                                     struct rte_flow *flow,
1387                                     struct rte_flow_error *error, int ip6)
1388 {
1389         const struct rte_flow_item *item = mrvl_next_item(pattern);
1390         int ret;
1391
1392         ret = mrvl_parse_eth(item, flow, error);
1393         if (ret)
1394                 return ret;
1395
1396         item = mrvl_next_item(item + 1);
1397         ret = mrvl_parse_vlan(item, flow, error);
1398         if (ret)
1399                 return ret;
1400
1401         item = mrvl_next_item(item + 1);
1402
1403         return ip6 ? mrvl_parse_ip6(item, flow, error) :
1404                      mrvl_parse_ip4(item, flow, error);
1405 }
1406
1407 /**
1408  * Parse flow pattern composed of the eth, vlan and ipv4 items.
1409  *
1410  * @param pattern Pointer to the flow pattern table.
1411  * @param flow Pointer to the flow.
1412  * @param error Pointer to the flow error.
1413  * @returns 0 in case of success, negative value otherwise.
1414  */
1415 static int
1416 mrvl_parse_pattern_eth_vlan_ip4(const struct rte_flow_item pattern[],
1417                                 struct rte_flow *flow,
1418                                 struct rte_flow_error *error)
1419 {
1420         return mrvl_parse_pattern_eth_vlan_ip4_ip6(pattern, flow, error, 0);
1421 }
1422
1423 /**
1424  * Parse flow pattern composed of the eth, vlan and ipv6 items.
1425  *
1426  * @param pattern Pointer to the flow pattern table.
1427  * @param flow Pointer to the flow.
1428  * @param error Pointer to the flow error.
1429  * @returns 0 in case of success, negative value otherwise.
1430  */
1431 static int
1432 mrvl_parse_pattern_eth_vlan_ip6(const struct rte_flow_item pattern[],
1433                                 struct rte_flow *flow,
1434                                 struct rte_flow_error *error)
1435 {
1436         return mrvl_parse_pattern_eth_vlan_ip4_ip6(pattern, flow, error, 1);
1437 }
1438
1439 /**
1440  * Parse flow pattern composed of the eth and ip4/ip6 items.
1441  *
1442  * @param pattern Pointer to the flow pattern table.
1443  * @param flow Pointer to the flow.
1444  * @param error Pointer to the flow error.
1445  * @param ip6 1 to parse ip6 item, 0 to parse ip4 item.
1446  * @returns 0 in case of success, negative value otherwise.
1447  */
1448 static int
1449 mrvl_parse_pattern_eth_ip4_ip6(const struct rte_flow_item pattern[],
1450                                struct rte_flow *flow,
1451                                struct rte_flow_error *error, int ip6)
1452 {
1453         const struct rte_flow_item *item = mrvl_next_item(pattern);
1454         int ret;
1455
1456         ret = mrvl_parse_eth(item, flow, error);
1457         if (ret)
1458                 return ret;
1459
1460         item = mrvl_next_item(item + 1);
1461
1462         return ip6 ? mrvl_parse_ip6(item, flow, error) :
1463                      mrvl_parse_ip4(item, flow, error);
1464 }
1465
1466 /**
1467  * Parse flow pattern composed of the eth and ipv4 items.
1468  *
1469  * @param pattern Pointer to the flow pattern table.
1470  * @param flow Pointer to the flow.
1471  * @param error Pointer to the flow error.
1472  * @returns 0 in case of success, negative value otherwise.
1473  */
1474 static inline int
1475 mrvl_parse_pattern_eth_ip4(const struct rte_flow_item pattern[],
1476                            struct rte_flow *flow,
1477                            struct rte_flow_error *error)
1478 {
1479         return mrvl_parse_pattern_eth_ip4_ip6(pattern, flow, error, 0);
1480 }
1481
1482 /**
1483  * Parse flow pattern composed of the eth and ipv6 items.
1484  *
1485  * @param pattern Pointer to the flow pattern table.
1486  * @param flow Pointer to the flow.
1487  * @param error Pointer to the flow error.
1488  * @returns 0 in case of success, negative value otherwise.
1489  */
1490 static inline int
1491 mrvl_parse_pattern_eth_ip6(const struct rte_flow_item pattern[],
1492                            struct rte_flow *flow,
1493                            struct rte_flow_error *error)
1494 {
1495         return mrvl_parse_pattern_eth_ip4_ip6(pattern, flow, error, 1);
1496 }
1497
1498 /**
1499  * Parse flow pattern composed of the eth, ip4 and tcp/udp items.
1500  *
1501  * @param pattern Pointer to the flow pattern table.
1502  * @param flow Pointer to the flow.
1503  * @param error Pointer to the flow error.
1504  * @param tcp 1 to parse tcp item, 0 to parse udp item.
1505  * @returns 0 in case of success, negative value otherwise.
1506  */
1507 static int
1508 mrvl_parse_pattern_eth_ip4_tcp_udp(const struct rte_flow_item pattern[],
1509                                    struct rte_flow *flow,
1510                                    struct rte_flow_error *error, int tcp)
1511 {
1512         const struct rte_flow_item *item = mrvl_next_item(pattern);
1513         int ret;
1514
1515         ret = mrvl_parse_pattern_eth_ip4_ip6(pattern, flow, error, 0);
1516         if (ret)
1517                 return ret;
1518
1519         item = mrvl_next_item(item + 1);
1520         item = mrvl_next_item(item + 1);
1521
1522         if (tcp)
1523                 return mrvl_parse_tcp(item, flow, error);
1524
1525         return mrvl_parse_udp(item, flow, error);
1526 }
1527
1528 /**
1529  * Parse flow pattern composed of the eth, ipv4 and tcp items.
1530  *
1531  * @param pattern Pointer to the flow pattern table.
1532  * @param flow Pointer to the flow.
1533  * @param error Pointer to the flow error.
1534  * @returns 0 in case of success, negative value otherwise.
1535  */
1536 static inline int
1537 mrvl_parse_pattern_eth_ip4_tcp(const struct rte_flow_item pattern[],
1538                                struct rte_flow *flow,
1539                                struct rte_flow_error *error)
1540 {
1541         return mrvl_parse_pattern_eth_ip4_tcp_udp(pattern, flow, error, 1);
1542 }
1543
1544 /**
1545  * Parse flow pattern composed of the eth, ipv4 and udp items.
1546  *
1547  * @param pattern Pointer to the flow pattern table.
1548  * @param flow Pointer to the flow.
1549  * @param error Pointer to the flow error.
1550  * @returns 0 in case of success, negative value otherwise.
1551  */
1552 static inline int
1553 mrvl_parse_pattern_eth_ip4_udp(const struct rte_flow_item pattern[],
1554                                struct rte_flow *flow,
1555                                struct rte_flow_error *error)
1556 {
1557         return mrvl_parse_pattern_eth_ip4_tcp_udp(pattern, flow, error, 0);
1558 }
1559
1560 /**
1561  * Parse flow pattern composed of the eth, ipv6 and tcp/udp items.
1562  *
1563  * @param pattern Pointer to the flow pattern table.
1564  * @param flow Pointer to the flow.
1565  * @param error Pointer to the flow error.
1566  * @param tcp 1 to parse tcp item, 0 to parse udp item.
1567  * @returns 0 in case of success, negative value otherwise.
1568  */
1569 static int
1570 mrvl_parse_pattern_eth_ip6_tcp_udp(const struct rte_flow_item pattern[],
1571                                    struct rte_flow *flow,
1572                                    struct rte_flow_error *error, int tcp)
1573 {
1574         const struct rte_flow_item *item = mrvl_next_item(pattern);
1575         int ret;
1576
1577         ret = mrvl_parse_pattern_eth_ip4_ip6(pattern, flow, error, 1);
1578         if (ret)
1579                 return ret;
1580
1581         item = mrvl_next_item(item + 1);
1582         item = mrvl_next_item(item + 1);
1583
1584         if (tcp)
1585                 return mrvl_parse_tcp(item, flow, error);
1586
1587         return mrvl_parse_udp(item, flow, error);
1588 }
1589
1590 /**
1591  * Parse flow pattern composed of the eth, ipv6 and tcp items.
1592  *
1593  * @param pattern Pointer to the flow pattern table.
1594  * @param flow Pointer to the flow.
1595  * @param error Pointer to the flow error.
1596  * @returns 0 in case of success, negative value otherwise.
1597  */
1598 static inline int
1599 mrvl_parse_pattern_eth_ip6_tcp(const struct rte_flow_item pattern[],
1600                                struct rte_flow *flow,
1601                                struct rte_flow_error *error)
1602 {
1603         return mrvl_parse_pattern_eth_ip6_tcp_udp(pattern, flow, error, 1);
1604 }
1605
1606 /**
1607  * Parse flow pattern composed of the eth, ipv6 and udp items.
1608  *
1609  * @param pattern Pointer to the flow pattern table.
1610  * @param flow Pointer to the flow.
1611  * @param error Pointer to the flow error.
1612  * @returns 0 in case of success, negative value otherwise.
1613  */
1614 static inline int
1615 mrvl_parse_pattern_eth_ip6_udp(const struct rte_flow_item pattern[],
1616                                struct rte_flow *flow,
1617                                struct rte_flow_error *error)
1618 {
1619         return mrvl_parse_pattern_eth_ip6_tcp_udp(pattern, flow, error, 0);
1620 }
1621
1622 /**
1623  * Parse flow pattern composed of the vlan item.
1624  *
1625  * @param pattern Pointer to the flow pattern table.
1626  * @param flow Pointer to the flow.
1627  * @param error Pointer to the flow error.
1628  * @returns 0 in case of success, negative value otherwise.
1629  */
1630 static int
1631 mrvl_parse_pattern_vlan(const struct rte_flow_item pattern[],
1632                             struct rte_flow *flow,
1633                             struct rte_flow_error *error)
1634 {
1635         const struct rte_flow_item *item = mrvl_next_item(pattern);
1636
1637         return mrvl_parse_vlan(item, flow, error);
1638 }
1639
1640 /**
1641  * Parse flow pattern composed of the vlan and ip4/ip6 items.
1642  *
1643  * @param pattern Pointer to the flow pattern table.
1644  * @param flow Pointer to the flow.
1645  * @param error Pointer to the flow error.
1646  * @param ip6 1 to parse ip6 item, 0 to parse ip4 item.
1647  * @returns 0 in case of success, negative value otherwise.
1648  */
1649 static int
1650 mrvl_parse_pattern_vlan_ip4_ip6(const struct rte_flow_item pattern[],
1651                                 struct rte_flow *flow,
1652                                 struct rte_flow_error *error, int ip6)
1653 {
1654         const struct rte_flow_item *item = mrvl_next_item(pattern);
1655         int ret;
1656
1657         ret = mrvl_parse_vlan(item, flow, error);
1658         if (ret)
1659                 return ret;
1660
1661         item = mrvl_next_item(item + 1);
1662
1663         return ip6 ? mrvl_parse_ip6(item, flow, error) :
1664                      mrvl_parse_ip4(item, flow, error);
1665 }
1666
1667 /**
1668  * Parse flow pattern composed of the vlan and ipv4 items.
1669  *
1670  * @param pattern Pointer to the flow pattern table.
1671  * @param flow Pointer to the flow.
1672  * @param error Pointer to the flow error.
1673  * @returns 0 in case of success, negative value otherwise.
1674  */
1675 static inline int
1676 mrvl_parse_pattern_vlan_ip4(const struct rte_flow_item pattern[],
1677                             struct rte_flow *flow,
1678                             struct rte_flow_error *error)
1679 {
1680         return mrvl_parse_pattern_vlan_ip4_ip6(pattern, flow, error, 0);
1681 }
1682
1683 /**
1684  * Parse flow pattern composed of the vlan, ipv4 and tcp/udp items.
1685  *
1686  * @param pattern Pointer to the flow pattern table.
1687  * @param flow Pointer to the flow.
1688  * @param error Pointer to the flow error.
1689  * @returns 0 in case of success, negative value otherwise.
1690  */
1691 static int
1692 mrvl_parse_pattern_vlan_ip_tcp_udp(const struct rte_flow_item pattern[],
1693                                    struct rte_flow *flow,
1694                                    struct rte_flow_error *error, int tcp)
1695 {
1696         const struct rte_flow_item *item = mrvl_next_item(pattern);
1697         int ret;
1698
1699         ret = mrvl_parse_pattern_vlan_ip4_ip6(pattern, flow, error, 0);
1700         if (ret)
1701                 return ret;
1702
1703         item = mrvl_next_item(item + 1);
1704         item = mrvl_next_item(item + 1);
1705
1706         if (tcp)
1707                 return mrvl_parse_tcp(item, flow, error);
1708
1709         return mrvl_parse_udp(item, flow, error);
1710 }
1711
1712 /**
1713  * Parse flow pattern composed of the vlan, ipv4 and tcp items.
1714  *
1715  * @param pattern Pointer to the flow pattern table.
1716  * @param flow Pointer to the flow.
1717  * @param error Pointer to the flow error.
1718  * @returns 0 in case of success, negative value otherwise.
1719  */
1720 static inline int
1721 mrvl_parse_pattern_vlan_ip_tcp(const struct rte_flow_item pattern[],
1722                                struct rte_flow *flow,
1723                                struct rte_flow_error *error)
1724 {
1725         return mrvl_parse_pattern_vlan_ip_tcp_udp(pattern, flow, error, 1);
1726 }
1727
1728 /**
1729  * Parse flow pattern composed of the vlan, ipv4 and udp items.
1730  *
1731  * @param pattern Pointer to the flow pattern table.
1732  * @param flow Pointer to the flow.
1733  * @param error Pointer to the flow error.
1734  * @returns 0 in case of success, negative value otherwise.
1735  */
1736 static inline int
1737 mrvl_parse_pattern_vlan_ip_udp(const struct rte_flow_item pattern[],
1738                                struct rte_flow *flow,
1739                                struct rte_flow_error *error)
1740 {
1741         return mrvl_parse_pattern_vlan_ip_tcp_udp(pattern, flow, error, 0);
1742 }
1743
1744 /**
1745  * Parse flow pattern composed of the vlan and ipv6 items.
1746  *
1747  * @param pattern Pointer to the flow pattern table.
1748  * @param flow Pointer to the flow.
1749  * @param error Pointer to the flow error.
1750  * @returns 0 in case of success, negative value otherwise.
1751  */
1752 static inline int
1753 mrvl_parse_pattern_vlan_ip6(const struct rte_flow_item pattern[],
1754                             struct rte_flow *flow,
1755                             struct rte_flow_error *error)
1756 {
1757         return mrvl_parse_pattern_vlan_ip4_ip6(pattern, flow, error, 1);
1758 }
1759
1760 /**
1761  * Parse flow pattern composed of the vlan, ipv6 and tcp/udp items.
1762  *
1763  * @param pattern Pointer to the flow pattern table.
1764  * @param flow Pointer to the flow.
1765  * @param error Pointer to the flow error.
1766  * @returns 0 in case of success, negative value otherwise.
1767  */
1768 static int
1769 mrvl_parse_pattern_vlan_ip6_tcp_udp(const struct rte_flow_item pattern[],
1770                                     struct rte_flow *flow,
1771                                     struct rte_flow_error *error, int tcp)
1772 {
1773         const struct rte_flow_item *item = mrvl_next_item(pattern);
1774         int ret;
1775
1776         ret = mrvl_parse_pattern_vlan_ip4_ip6(pattern, flow, error, 1);
1777         if (ret)
1778                 return ret;
1779
1780         item = mrvl_next_item(item + 1);
1781         item = mrvl_next_item(item + 1);
1782
1783         if (tcp)
1784                 return mrvl_parse_tcp(item, flow, error);
1785
1786         return mrvl_parse_udp(item, flow, error);
1787 }
1788
1789 /**
1790  * Parse flow pattern composed of the vlan, ipv6 and tcp items.
1791  *
1792  * @param pattern Pointer to the flow pattern table.
1793  * @param flow Pointer to the flow.
1794  * @param error Pointer to the flow error.
1795  * @returns 0 in case of success, negative value otherwise.
1796  */
1797 static inline int
1798 mrvl_parse_pattern_vlan_ip6_tcp(const struct rte_flow_item pattern[],
1799                                 struct rte_flow *flow,
1800                                 struct rte_flow_error *error)
1801 {
1802         return mrvl_parse_pattern_vlan_ip6_tcp_udp(pattern, flow, error, 1);
1803 }
1804
1805 /**
1806  * Parse flow pattern composed of the vlan, ipv6 and udp items.
1807  *
1808  * @param pattern Pointer to the flow pattern table.
1809  * @param flow Pointer to the flow.
1810  * @param error Pointer to the flow error.
1811  * @returns 0 in case of success, negative value otherwise.
1812  */
1813 static inline int
1814 mrvl_parse_pattern_vlan_ip6_udp(const struct rte_flow_item pattern[],
1815                                 struct rte_flow *flow,
1816                                 struct rte_flow_error *error)
1817 {
1818         return mrvl_parse_pattern_vlan_ip6_tcp_udp(pattern, flow, error, 0);
1819 }
1820
1821 /**
1822  * Parse flow pattern composed of the ip4/ip6 item.
1823  *
1824  * @param pattern Pointer to the flow pattern table.
1825  * @param flow Pointer to the flow.
1826  * @param error Pointer to the flow error.
1827  * @param ip6 1 to parse ip6 item, 0 to parse ip4 item.
1828  * @returns 0 in case of success, negative value otherwise.
1829  */
1830 static int
1831 mrvl_parse_pattern_ip4_ip6(const struct rte_flow_item pattern[],
1832                        struct rte_flow *flow,
1833                        struct rte_flow_error *error, int ip6)
1834 {
1835         const struct rte_flow_item *item = mrvl_next_item(pattern);
1836
1837         return ip6 ? mrvl_parse_ip6(item, flow, error) :
1838                      mrvl_parse_ip4(item, flow, error);
1839 }
1840
1841 /**
1842  * Parse flow pattern composed of the ipv4 item.
1843  *
1844  * @param pattern Pointer to the flow pattern table.
1845  * @param flow Pointer to the flow.
1846  * @param error Pointer to the flow error.
1847  * @returns 0 in case of success, negative value otherwise.
1848  */
1849 static inline int
1850 mrvl_parse_pattern_ip4(const struct rte_flow_item pattern[],
1851                        struct rte_flow *flow,
1852                        struct rte_flow_error *error)
1853 {
1854         return mrvl_parse_pattern_ip4_ip6(pattern, flow, error, 0);
1855 }
1856
1857 /**
1858  * Parse flow pattern composed of the ipv6 item.
1859  *
1860  * @param pattern Pointer to the flow pattern table.
1861  * @param flow Pointer to the flow.
1862  * @param error Pointer to the flow error.
1863  * @returns 0 in case of success, negative value otherwise.
1864  */
1865 static inline int
1866 mrvl_parse_pattern_ip6(const struct rte_flow_item pattern[],
1867                        struct rte_flow *flow,
1868                        struct rte_flow_error *error)
1869 {
1870         return mrvl_parse_pattern_ip4_ip6(pattern, flow, error, 1);
1871 }
1872
1873 /**
1874  * Parse flow pattern composed of the ip4/ip6 and tcp items.
1875  *
1876  * @param pattern Pointer to the flow pattern table.
1877  * @param flow Pointer to the flow.
1878  * @param error Pointer to the flow error.
1879  * @param ip6 1 to parse ip6 item, 0 to parse ip4 item.
1880  * @returns 0 in case of success, negative value otherwise.
1881  */
1882 static int
1883 mrvl_parse_pattern_ip4_ip6_tcp(const struct rte_flow_item pattern[],
1884                            struct rte_flow *flow,
1885                            struct rte_flow_error *error, int ip6)
1886 {
1887         const struct rte_flow_item *item = mrvl_next_item(pattern);
1888         int ret;
1889
1890         ret = ip6 ? mrvl_parse_ip6(item, flow, error) :
1891                     mrvl_parse_ip4(item, flow, error);
1892         if (ret)
1893                 return ret;
1894
1895         item = mrvl_next_item(item + 1);
1896
1897         return mrvl_parse_tcp(item, flow, error);
1898 }
1899
1900 /**
1901  * Parse flow pattern composed of the ipv4 and tcp items.
1902  *
1903  * @param pattern Pointer to the flow pattern table.
1904  * @param flow Pointer to the flow.
1905  * @param error Pointer to the flow error.
1906  * @returns 0 in case of success, negative value otherwise.
1907  */
1908 static inline int
1909 mrvl_parse_pattern_ip4_tcp(const struct rte_flow_item pattern[],
1910                            struct rte_flow *flow,
1911                            struct rte_flow_error *error)
1912 {
1913         return mrvl_parse_pattern_ip4_ip6_tcp(pattern, flow, error, 0);
1914 }
1915
1916 /**
1917  * Parse flow pattern composed of the ipv6 and tcp items.
1918  *
1919  * @param pattern Pointer to the flow pattern table.
1920  * @param flow Pointer to the flow.
1921  * @param error Pointer to the flow error.
1922  * @returns 0 in case of success, negative value otherwise.
1923  */
1924 static inline int
1925 mrvl_parse_pattern_ip6_tcp(const struct rte_flow_item pattern[],
1926                            struct rte_flow *flow,
1927                            struct rte_flow_error *error)
1928 {
1929         return mrvl_parse_pattern_ip4_ip6_tcp(pattern, flow, error, 1);
1930 }
1931
1932 /**
1933  * Parse flow pattern composed of the ipv4/ipv6 and udp items.
1934  *
1935  * @param pattern Pointer to the flow pattern table.
1936  * @param flow Pointer to the flow.
1937  * @param error Pointer to the flow error.
1938  * @param ip6 1 to parse ip6 item, 0 to parse ip4 item.
1939  * @returns 0 in case of success, negative value otherwise.
1940  */
1941 static int
1942 mrvl_parse_pattern_ip4_ip6_udp(const struct rte_flow_item pattern[],
1943                            struct rte_flow *flow,
1944                            struct rte_flow_error *error, int ip6)
1945 {
1946         const struct rte_flow_item *item = mrvl_next_item(pattern);
1947         int ret;
1948
1949         ret = ip6 ? mrvl_parse_ip6(item, flow, error) :
1950                     mrvl_parse_ip4(item, flow, error);
1951         if (ret)
1952                 return ret;
1953
1954         item = mrvl_next_item(item + 1);
1955
1956         return mrvl_parse_udp(item, flow, error);
1957 }
1958
1959 /**
1960  * Parse flow pattern composed of the ipv4 and udp items.
1961  *
1962  * @param pattern Pointer to the flow pattern table.
1963  * @param flow Pointer to the flow.
1964  * @param error Pointer to the flow error.
1965  * @returns 0 in case of success, negative value otherwise.
1966  */
1967 static inline int
1968 mrvl_parse_pattern_ip4_udp(const struct rte_flow_item pattern[],
1969                            struct rte_flow *flow,
1970                            struct rte_flow_error *error)
1971 {
1972         return mrvl_parse_pattern_ip4_ip6_udp(pattern, flow, error, 0);
1973 }
1974
1975 /**
1976  * Parse flow pattern composed of the ipv6 and udp items.
1977  *
1978  * @param pattern Pointer to the flow pattern table.
1979  * @param flow Pointer to the flow.
1980  * @param error Pointer to the flow error.
1981  * @returns 0 in case of success, negative value otherwise.
1982  */
1983 static inline int
1984 mrvl_parse_pattern_ip6_udp(const struct rte_flow_item pattern[],
1985                            struct rte_flow *flow,
1986                            struct rte_flow_error *error)
1987 {
1988         return mrvl_parse_pattern_ip4_ip6_udp(pattern, flow, error, 1);
1989 }
1990
1991 /**
1992  * Parse flow pattern composed of the tcp item.
1993  *
1994  * @param pattern Pointer to the flow pattern table.
1995  * @param flow Pointer to the flow.
1996  * @param error Pointer to the flow error.
1997  * @returns 0 in case of success, negative value otherwise.
1998  */
1999 static int
2000 mrvl_parse_pattern_tcp(const struct rte_flow_item pattern[],
2001                        struct rte_flow *flow,
2002                        struct rte_flow_error *error)
2003 {
2004         const struct rte_flow_item *item = mrvl_next_item(pattern);
2005
2006         return mrvl_parse_tcp(item, flow, error);
2007 }
2008
2009 /**
2010  * Parse flow pattern composed of the udp item.
2011  *
2012  * @param pattern Pointer to the flow pattern table.
2013  * @param flow Pointer to the flow.
2014  * @param error Pointer to the flow error.
2015  * @returns 0 in case of success, negative value otherwise.
2016  */
2017 static int
2018 mrvl_parse_pattern_udp(const struct rte_flow_item pattern[],
2019                        struct rte_flow *flow,
2020                        struct rte_flow_error *error)
2021 {
2022         const struct rte_flow_item *item = mrvl_next_item(pattern);
2023
2024         return mrvl_parse_udp(item, flow, error);
2025 }
2026
2027 /**
2028  * Structure used to map specific flow pattern to the pattern parse callback
2029  * which will iterate over each pattern item and extract relevant data.
2030  */
2031 static const struct {
2032         const enum rte_flow_item_type *pattern;
2033         int (*parse)(const struct rte_flow_item pattern[],
2034                 struct rte_flow *flow,
2035                 struct rte_flow_error *error);
2036 } mrvl_patterns[] = {
2037         { pattern_eth, mrvl_parse_pattern_eth },
2038         { pattern_eth_vlan, mrvl_parse_pattern_eth_vlan },
2039         { pattern_eth_vlan_ip, mrvl_parse_pattern_eth_vlan_ip4 },
2040         { pattern_eth_vlan_ip6, mrvl_parse_pattern_eth_vlan_ip6 },
2041         { pattern_eth_ip4, mrvl_parse_pattern_eth_ip4 },
2042         { pattern_eth_ip4_tcp, mrvl_parse_pattern_eth_ip4_tcp },
2043         { pattern_eth_ip4_udp, mrvl_parse_pattern_eth_ip4_udp },
2044         { pattern_eth_ip6, mrvl_parse_pattern_eth_ip6 },
2045         { pattern_eth_ip6_tcp, mrvl_parse_pattern_eth_ip6_tcp },
2046         { pattern_eth_ip6_udp, mrvl_parse_pattern_eth_ip6_udp },
2047         { pattern_vlan, mrvl_parse_pattern_vlan },
2048         { pattern_vlan_ip, mrvl_parse_pattern_vlan_ip4 },
2049         { pattern_vlan_ip_tcp, mrvl_parse_pattern_vlan_ip_tcp },
2050         { pattern_vlan_ip_udp, mrvl_parse_pattern_vlan_ip_udp },
2051         { pattern_vlan_ip6, mrvl_parse_pattern_vlan_ip6 },
2052         { pattern_vlan_ip6_tcp, mrvl_parse_pattern_vlan_ip6_tcp },
2053         { pattern_vlan_ip6_udp, mrvl_parse_pattern_vlan_ip6_udp },
2054         { pattern_ip, mrvl_parse_pattern_ip4 },
2055         { pattern_ip_tcp, mrvl_parse_pattern_ip4_tcp },
2056         { pattern_ip_udp, mrvl_parse_pattern_ip4_udp },
2057         { pattern_ip6, mrvl_parse_pattern_ip6 },
2058         { pattern_ip6_tcp, mrvl_parse_pattern_ip6_tcp },
2059         { pattern_ip6_udp, mrvl_parse_pattern_ip6_udp },
2060         { pattern_tcp, mrvl_parse_pattern_tcp },
2061         { pattern_udp, mrvl_parse_pattern_udp }
2062 };
2063
2064 /**
2065  * Check whether provided pattern matches any of the supported ones.
2066  *
2067  * @param type_pattern Pointer to the pattern type.
2068  * @param item_pattern Pointer to the flow pattern.
2069  * @returns 1 in case of success, 0 value otherwise.
2070  */
2071 static int
2072 mrvl_patterns_match(const enum rte_flow_item_type *type_pattern,
2073                     const struct rte_flow_item *item_pattern)
2074 {
2075         const enum rte_flow_item_type *type = type_pattern;
2076         const struct rte_flow_item *item = item_pattern;
2077
2078         for (;;) {
2079                 if (item->type == RTE_FLOW_ITEM_TYPE_VOID) {
2080                         item++;
2081                         continue;
2082                 }
2083
2084                 if (*type == RTE_FLOW_ITEM_TYPE_END ||
2085                     item->type == RTE_FLOW_ITEM_TYPE_END)
2086                         break;
2087
2088                 if (*type != item->type)
2089                         break;
2090
2091                 item++;
2092                 type++;
2093         }
2094
2095         return *type == item->type;
2096 }
2097
2098 /**
2099  * Parse flow attribute.
2100  *
2101  * This will check whether the provided attribute's flags are supported.
2102  *
2103  * @param priv Unused
2104  * @param attr Pointer to the flow attribute.
2105  * @param flow Unused
2106  * @param error Pointer to the flow error.
2107  * @returns 0 in case of success, negative value otherwise.
2108  */
2109 static int
2110 mrvl_flow_parse_attr(struct mrvl_priv *priv __rte_unused,
2111                      const struct rte_flow_attr *attr,
2112                      struct rte_flow *flow __rte_unused,
2113                      struct rte_flow_error *error)
2114 {
2115         if (!attr) {
2116                 rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ATTR,
2117                                    NULL, "NULL attribute");
2118                 return -rte_errno;
2119         }
2120
2121         if (attr->group) {
2122                 rte_flow_error_set(error, ENOTSUP,
2123                                    RTE_FLOW_ERROR_TYPE_ATTR_GROUP, NULL,
2124                                    "Groups are not supported");
2125                 return -rte_errno;
2126         }
2127         if (attr->priority) {
2128                 rte_flow_error_set(error, ENOTSUP,
2129                                    RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY, NULL,
2130                                    "Priorities are not supported");
2131                 return -rte_errno;
2132         }
2133         if (!attr->ingress) {
2134                 rte_flow_error_set(error, ENOTSUP,
2135                                    RTE_FLOW_ERROR_TYPE_ATTR_INGRESS, NULL,
2136                                    "Only ingress is supported");
2137                 return -rte_errno;
2138         }
2139         if (attr->egress) {
2140                 rte_flow_error_set(error, ENOTSUP,
2141                                    RTE_FLOW_ERROR_TYPE_ATTR_EGRESS, NULL,
2142                                    "Egress is not supported");
2143                 return -rte_errno;
2144         }
2145         if (attr->transfer) {
2146                 rte_flow_error_set(error, ENOTSUP,
2147                                    RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER, NULL,
2148                                    "Transfer is not supported");
2149                 return -rte_errno;
2150         }
2151
2152         return 0;
2153 }
2154
2155 /**
2156  * Parse flow pattern.
2157  *
2158  * Specific classifier rule will be created as well.
2159  *
2160  * @param priv Unused
2161  * @param pattern Pointer to the flow pattern.
2162  * @param flow Pointer to the flow.
2163  * @param error Pointer to the flow error.
2164  * @returns 0 in case of success, negative value otherwise.
2165  */
2166 static int
2167 mrvl_flow_parse_pattern(struct mrvl_priv *priv __rte_unused,
2168                         const struct rte_flow_item pattern[],
2169                         struct rte_flow *flow,
2170                         struct rte_flow_error *error)
2171 {
2172         unsigned int i;
2173         int ret;
2174
2175         for (i = 0; i < RTE_DIM(mrvl_patterns); i++) {
2176                 if (!mrvl_patterns_match(mrvl_patterns[i].pattern, pattern))
2177                         continue;
2178
2179                 ret = mrvl_patterns[i].parse(pattern, flow, error);
2180                 if (ret)
2181                         mrvl_free_all_key_mask(&flow->rule);
2182
2183                 return ret;
2184         }
2185
2186         rte_flow_error_set(error, ENOTSUP, RTE_FLOW_ERROR_TYPE_ITEM, NULL,
2187                            "Unsupported pattern");
2188
2189         return -rte_errno;
2190 }
2191
2192 /**
2193  * Parse flow actions.
2194  *
2195  * @param priv Pointer to the port's private data.
2196  * @param actions Pointer the action table.
2197  * @param flow Pointer to the flow.
2198  * @param error Pointer to the flow error.
2199  * @returns 0 in case of success, negative value otherwise.
2200  */
2201 static int
2202 mrvl_flow_parse_actions(struct mrvl_priv *priv,
2203                         const struct rte_flow_action actions[],
2204                         struct rte_flow *flow,
2205                         struct rte_flow_error *error)
2206 {
2207         const struct rte_flow_action *action = actions;
2208         int specified = 0;
2209
2210         for (; action->type != RTE_FLOW_ACTION_TYPE_END; action++) {
2211                 if (action->type == RTE_FLOW_ACTION_TYPE_VOID)
2212                         continue;
2213
2214                 if (action->type == RTE_FLOW_ACTION_TYPE_DROP) {
2215                         flow->cos.ppio = priv->ppio;
2216                         flow->cos.tc = 0;
2217                         flow->action.type = PP2_CLS_TBL_ACT_DROP;
2218                         flow->action.cos = &flow->cos;
2219                         specified++;
2220                 } else if (action->type == RTE_FLOW_ACTION_TYPE_QUEUE) {
2221                         const struct rte_flow_action_queue *q =
2222                                 (const struct rte_flow_action_queue *)
2223                                 action->conf;
2224
2225                         if (q->index > priv->nb_rx_queues) {
2226                                 rte_flow_error_set(error, EINVAL,
2227                                                 RTE_FLOW_ERROR_TYPE_ACTION,
2228                                                 NULL,
2229                                                 "Queue index out of range");
2230                                 return -rte_errno;
2231                         }
2232
2233                         if (priv->rxq_map[q->index].tc == MRVL_UNKNOWN_TC) {
2234                                 /*
2235                                  * Unknown TC mapping, mapping will not have
2236                                  * a correct queue.
2237                                  */
2238                                 MRVL_LOG(ERR,
2239                                         "Unknown TC mapping for queue %hu eth%hhu",
2240                                         q->index, priv->ppio_id);
2241
2242                                 rte_flow_error_set(error, EFAULT,
2243                                                 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
2244                                                 NULL, NULL);
2245                                 return -rte_errno;
2246                         }
2247
2248                         MRVL_LOG(DEBUG,
2249                                 "Action: Assign packets to queue %d, tc:%d, q:%d",
2250                                 q->index, priv->rxq_map[q->index].tc,
2251                                 priv->rxq_map[q->index].inq);
2252
2253                         flow->cos.ppio = priv->ppio;
2254                         flow->cos.tc = priv->rxq_map[q->index].tc;
2255                         flow->action.type = PP2_CLS_TBL_ACT_DONE;
2256                         flow->action.cos = &flow->cos;
2257                         specified++;
2258                 } else if (action->type == RTE_FLOW_ACTION_TYPE_METER) {
2259                         const struct rte_flow_action_meter *meter;
2260                         struct mrvl_mtr *mtr;
2261
2262                         meter = action->conf;
2263                         if (!meter)
2264                                 return -rte_flow_error_set(error, EINVAL,
2265                                                 RTE_FLOW_ERROR_TYPE_ACTION,
2266                                                 NULL, "Invalid meter\n");
2267
2268                         LIST_FOREACH(mtr, &priv->mtrs, next)
2269                                 if (mtr->mtr_id == meter->mtr_id)
2270                                         break;
2271
2272                         if (!mtr)
2273                                 return -rte_flow_error_set(error, EINVAL,
2274                                                 RTE_FLOW_ERROR_TYPE_ACTION,
2275                                                 NULL,
2276                                                 "Meter id does not exist\n");
2277
2278                         if (!mtr->shared && mtr->refcnt)
2279                                 return -rte_flow_error_set(error, EPERM,
2280                                                 RTE_FLOW_ERROR_TYPE_ACTION,
2281                                                 NULL,
2282                                                 "Meter cannot be shared\n");
2283
2284                         /*
2285                          * In case cos has already been set
2286                          * do not modify it.
2287                          */
2288                         if (!flow->cos.ppio) {
2289                                 flow->cos.ppio = priv->ppio;
2290                                 flow->cos.tc = 0;
2291                         }
2292
2293                         flow->action.type = PP2_CLS_TBL_ACT_DONE;
2294                         flow->action.cos = &flow->cos;
2295                         flow->action.plcr = mtr->enabled ? mtr->plcr : NULL;
2296                         flow->mtr = mtr;
2297                         mtr->refcnt++;
2298                         specified++;
2299                 } else {
2300                         rte_flow_error_set(error, ENOTSUP,
2301                                            RTE_FLOW_ERROR_TYPE_ACTION, NULL,
2302                                            "Action not supported");
2303                         return -rte_errno;
2304                 }
2305         }
2306
2307         if (!specified) {
2308                 rte_flow_error_set(error, EINVAL,
2309                                    RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
2310                                    "Action not specified");
2311                 return -rte_errno;
2312         }
2313
2314         return 0;
2315 }
2316
2317 /**
2318  * Parse flow attribute, pattern and actions.
2319  *
2320  * @param priv Pointer to the port's private data.
2321  * @param attr Pointer to the flow attribute.
2322  * @param pattern Pointer to the flow pattern.
2323  * @param actions Pointer to the flow actions.
2324  * @param flow Pointer to the flow.
2325  * @param error Pointer to the flow error.
2326  * @returns 0 on success, negative value otherwise.
2327  */
2328 static int
2329 mrvl_flow_parse(struct mrvl_priv *priv, const struct rte_flow_attr *attr,
2330                 const struct rte_flow_item pattern[],
2331                 const struct rte_flow_action actions[],
2332                 struct rte_flow *flow,
2333                 struct rte_flow_error *error)
2334 {
2335         int ret;
2336
2337         ret = mrvl_flow_parse_attr(priv, attr, flow, error);
2338         if (ret)
2339                 return ret;
2340
2341         ret = mrvl_flow_parse_pattern(priv, pattern, flow, error);
2342         if (ret)
2343                 return ret;
2344
2345         return mrvl_flow_parse_actions(priv, actions, flow, error);
2346 }
2347
2348 /**
2349  * Get engine type for the given flow.
2350  *
2351  * @param field Pointer to the flow.
2352  * @returns The type of the engine.
2353  */
2354 static inline enum pp2_cls_tbl_type
2355 mrvl_engine_type(const struct rte_flow *flow)
2356 {
2357         int i, size = 0;
2358
2359         for (i = 0; i < flow->rule.num_fields; i++)
2360                 size += flow->rule.fields[i].size;
2361
2362         /*
2363          * For maskable engine type the key size must be up to 8 bytes.
2364          * For keys with size bigger than 8 bytes, engine type must
2365          * be set to exact match.
2366          */
2367         if (size > 8)
2368                 return PP2_CLS_TBL_EXACT_MATCH;
2369
2370         return PP2_CLS_TBL_MASKABLE;
2371 }
2372
2373 /**
2374  * Create classifier table.
2375  *
2376  * @param dev Pointer to the device.
2377  * @param flow Pointer to the very first flow.
2378  * @returns 0 in case of success, negative value otherwise.
2379  */
2380 static int
2381 mrvl_create_cls_table(struct rte_eth_dev *dev, struct rte_flow *first_flow)
2382 {
2383         struct mrvl_priv *priv = dev->data->dev_private;
2384         struct pp2_cls_tbl_key *key = &priv->cls_tbl_params.key;
2385         int ret;
2386
2387         if (priv->cls_tbl) {
2388                 pp2_cls_tbl_deinit(priv->cls_tbl);
2389                 priv->cls_tbl = NULL;
2390         }
2391
2392         memset(&priv->cls_tbl_params, 0, sizeof(priv->cls_tbl_params));
2393
2394         priv->cls_tbl_params.type = mrvl_engine_type(first_flow);
2395         MRVL_LOG(INFO, "Setting cls search engine type to %s",
2396                         priv->cls_tbl_params.type == PP2_CLS_TBL_EXACT_MATCH ?
2397                         "exact" : "maskable");
2398         priv->cls_tbl_params.max_num_rules = MRVL_CLS_MAX_NUM_RULES;
2399         priv->cls_tbl_params.default_act.type = PP2_CLS_TBL_ACT_DONE;
2400         priv->cls_tbl_params.default_act.cos = &first_flow->cos;
2401
2402         if (first_flow->pattern & F_DMAC) {
2403                 key->proto_field[key->num_fields].proto = MV_NET_PROTO_ETH;
2404                 key->proto_field[key->num_fields].field.eth = MV_NET_ETH_F_DA;
2405                 key->key_size += 6;
2406                 key->num_fields += 1;
2407         }
2408
2409         if (first_flow->pattern & F_SMAC) {
2410                 key->proto_field[key->num_fields].proto = MV_NET_PROTO_ETH;
2411                 key->proto_field[key->num_fields].field.eth = MV_NET_ETH_F_SA;
2412                 key->key_size += 6;
2413                 key->num_fields += 1;
2414         }
2415
2416         if (first_flow->pattern & F_TYPE) {
2417                 key->proto_field[key->num_fields].proto = MV_NET_PROTO_ETH;
2418                 key->proto_field[key->num_fields].field.eth = MV_NET_ETH_F_TYPE;
2419                 key->key_size += 2;
2420                 key->num_fields += 1;
2421         }
2422
2423         if (first_flow->pattern & F_VLAN_ID) {
2424                 key->proto_field[key->num_fields].proto = MV_NET_PROTO_VLAN;
2425                 key->proto_field[key->num_fields].field.vlan = MV_NET_VLAN_F_ID;
2426                 key->key_size += 2;
2427                 key->num_fields += 1;
2428         }
2429
2430         if (first_flow->pattern & F_VLAN_PRI) {
2431                 key->proto_field[key->num_fields].proto = MV_NET_PROTO_VLAN;
2432                 key->proto_field[key->num_fields].field.vlan =
2433                         MV_NET_VLAN_F_PRI;
2434                 key->key_size += 1;
2435                 key->num_fields += 1;
2436         }
2437
2438         if (first_flow->pattern & F_IP4_TOS) {
2439                 key->proto_field[key->num_fields].proto = MV_NET_PROTO_IP4;
2440                 key->proto_field[key->num_fields].field.ipv4 =
2441                                                         MV_NET_IP4_F_DSCP;
2442                 key->key_size += 1;
2443                 key->num_fields += 1;
2444         }
2445
2446         if (first_flow->pattern & F_IP4_SIP) {
2447                 key->proto_field[key->num_fields].proto = MV_NET_PROTO_IP4;
2448                 key->proto_field[key->num_fields].field.ipv4 = MV_NET_IP4_F_SA;
2449                 key->key_size += 4;
2450                 key->num_fields += 1;
2451         }
2452
2453         if (first_flow->pattern & F_IP4_DIP) {
2454                 key->proto_field[key->num_fields].proto = MV_NET_PROTO_IP4;
2455                 key->proto_field[key->num_fields].field.ipv4 = MV_NET_IP4_F_DA;
2456                 key->key_size += 4;
2457                 key->num_fields += 1;
2458         }
2459
2460         if (first_flow->pattern & F_IP4_PROTO) {
2461                 key->proto_field[key->num_fields].proto = MV_NET_PROTO_IP4;
2462                 key->proto_field[key->num_fields].field.ipv4 =
2463                         MV_NET_IP4_F_PROTO;
2464                 key->key_size += 1;
2465                 key->num_fields += 1;
2466         }
2467
2468         if (first_flow->pattern & F_IP6_SIP) {
2469                 key->proto_field[key->num_fields].proto = MV_NET_PROTO_IP6;
2470                 key->proto_field[key->num_fields].field.ipv6 = MV_NET_IP6_F_SA;
2471                 key->key_size += 16;
2472                 key->num_fields += 1;
2473         }
2474
2475         if (first_flow->pattern & F_IP6_DIP) {
2476                 key->proto_field[key->num_fields].proto = MV_NET_PROTO_IP6;
2477                 key->proto_field[key->num_fields].field.ipv6 = MV_NET_IP6_F_DA;
2478                 key->key_size += 16;
2479                 key->num_fields += 1;
2480         }
2481
2482         if (first_flow->pattern & F_IP6_FLOW) {
2483                 key->proto_field[key->num_fields].proto = MV_NET_PROTO_IP6;
2484                 key->proto_field[key->num_fields].field.ipv6 =
2485                         MV_NET_IP6_F_FLOW;
2486                 key->key_size += 3;
2487                 key->num_fields += 1;
2488         }
2489
2490         if (first_flow->pattern & F_IP6_NEXT_HDR) {
2491                 key->proto_field[key->num_fields].proto = MV_NET_PROTO_IP6;
2492                 key->proto_field[key->num_fields].field.ipv6 =
2493                         MV_NET_IP6_F_NEXT_HDR;
2494                 key->key_size += 1;
2495                 key->num_fields += 1;
2496         }
2497
2498         if (first_flow->pattern & F_TCP_SPORT) {
2499                 key->proto_field[key->num_fields].proto = MV_NET_PROTO_TCP;
2500                 key->proto_field[key->num_fields].field.tcp = MV_NET_TCP_F_SP;
2501                 key->key_size += 2;
2502                 key->num_fields += 1;
2503         }
2504
2505         if (first_flow->pattern & F_TCP_DPORT) {
2506                 key->proto_field[key->num_fields].proto = MV_NET_PROTO_TCP;
2507                 key->proto_field[key->num_fields].field.tcp = MV_NET_TCP_F_DP;
2508                 key->key_size += 2;
2509                 key->num_fields += 1;
2510         }
2511
2512         if (first_flow->pattern & F_UDP_SPORT) {
2513                 key->proto_field[key->num_fields].proto = MV_NET_PROTO_UDP;
2514                 key->proto_field[key->num_fields].field.udp = MV_NET_UDP_F_SP;
2515                 key->key_size += 2;
2516                 key->num_fields += 1;
2517         }
2518
2519         if (first_flow->pattern & F_UDP_DPORT) {
2520                 key->proto_field[key->num_fields].proto = MV_NET_PROTO_UDP;
2521                 key->proto_field[key->num_fields].field.udp = MV_NET_UDP_F_DP;
2522                 key->key_size += 2;
2523                 key->num_fields += 1;
2524         }
2525
2526         ret = pp2_cls_tbl_init(&priv->cls_tbl_params, &priv->cls_tbl);
2527         if (!ret)
2528                 priv->cls_tbl_pattern = first_flow->pattern;
2529
2530         return ret;
2531 }
2532
2533 /**
2534  * Check whether new flow can be added to the table
2535  *
2536  * @param priv Pointer to the port's private data.
2537  * @param flow Pointer to the new flow.
2538  * @return 1 in case flow can be added, 0 otherwise.
2539  */
2540 static inline int
2541 mrvl_flow_can_be_added(struct mrvl_priv *priv, const struct rte_flow *flow)
2542 {
2543         return flow->pattern == priv->cls_tbl_pattern &&
2544                mrvl_engine_type(flow) == priv->cls_tbl_params.type;
2545 }
2546
2547 /**
2548  * DPDK flow create callback called when flow is to be created.
2549  *
2550  * @param dev Pointer to the device.
2551  * @param attr Pointer to the flow attribute.
2552  * @param pattern Pointer to the flow pattern.
2553  * @param actions Pointer to the flow actions.
2554  * @param error Pointer to the flow error.
2555  * @returns Pointer to the created flow in case of success, NULL otherwise.
2556  */
2557 static struct rte_flow *
2558 mrvl_flow_create(struct rte_eth_dev *dev,
2559                  const struct rte_flow_attr *attr,
2560                  const struct rte_flow_item pattern[],
2561                  const struct rte_flow_action actions[],
2562                  struct rte_flow_error *error)
2563 {
2564         struct mrvl_priv *priv = dev->data->dev_private;
2565         struct rte_flow *flow, *first;
2566         int ret;
2567
2568         if (!dev->data->dev_started) {
2569                 rte_flow_error_set(error, EINVAL,
2570                                    RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
2571                                    "Port must be started first\n");
2572                 return NULL;
2573         }
2574
2575         flow = rte_zmalloc_socket(NULL, sizeof(*flow), 0, rte_socket_id());
2576         if (!flow)
2577                 return NULL;
2578
2579         ret = mrvl_flow_parse(priv, attr, pattern, actions, flow, error);
2580         if (ret)
2581                 goto out;
2582
2583         /*
2584          * Four cases here:
2585          *
2586          * 1. In case table does not exist - create one.
2587          * 2. In case table exists, is empty and new flow cannot be added
2588          *    recreate table.
2589          * 3. In case table is not empty and new flow matches table format
2590          *    add it.
2591          * 4. Otherwise flow cannot be added.
2592          */
2593         first = LIST_FIRST(&priv->flows);
2594         if (!priv->cls_tbl) {
2595                 ret = mrvl_create_cls_table(dev, flow);
2596         } else if (!first && !mrvl_flow_can_be_added(priv, flow)) {
2597                 ret = mrvl_create_cls_table(dev, flow);
2598         } else if (mrvl_flow_can_be_added(priv, flow)) {
2599                 ret = 0;
2600         } else {
2601                 rte_flow_error_set(error, EINVAL,
2602                                    RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
2603                                    "Pattern does not match cls table format\n");
2604                 goto out;
2605         }
2606
2607         if (ret) {
2608                 rte_flow_error_set(error, EINVAL,
2609                                    RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
2610                                    "Failed to create cls table\n");
2611                 goto out;
2612         }
2613
2614         ret = pp2_cls_tbl_add_rule(priv->cls_tbl, &flow->rule, &flow->action);
2615         if (ret) {
2616                 rte_flow_error_set(error, EINVAL,
2617                                    RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
2618                                    "Failed to add rule\n");
2619                 goto out;
2620         }
2621
2622         LIST_INSERT_HEAD(&priv->flows, flow, next);
2623
2624         return flow;
2625 out:
2626         rte_free(flow);
2627         return NULL;
2628 }
2629
2630 /**
2631  * Remove classifier rule associated with given flow.
2632  *
2633  * @param priv Pointer to the port's private data.
2634  * @param flow Pointer to the flow.
2635  * @param error Pointer to the flow error.
2636  * @returns 0 in case of success, negative value otherwise.
2637  */
2638 static int
2639 mrvl_flow_remove(struct mrvl_priv *priv, struct rte_flow *flow,
2640                  struct rte_flow_error *error)
2641 {
2642         int ret;
2643
2644         if (!priv->cls_tbl) {
2645                 rte_flow_error_set(error, EINVAL,
2646                                    RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
2647                                    "Classifier table not initialized");
2648                 return -rte_errno;
2649         }
2650
2651         ret = pp2_cls_tbl_remove_rule(priv->cls_tbl, &flow->rule);
2652         if (ret) {
2653                 rte_flow_error_set(error, EINVAL,
2654                                    RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
2655                                    "Failed to remove rule");
2656                 return -rte_errno;
2657         }
2658
2659         mrvl_free_all_key_mask(&flow->rule);
2660
2661         if (flow->mtr) {
2662                 flow->mtr->refcnt--;
2663                 flow->mtr = NULL;
2664         }
2665
2666         return 0;
2667 }
2668
2669 /**
2670  * DPDK flow destroy callback called when flow is to be removed.
2671  *
2672  * @param dev Pointer to the device.
2673  * @param flow Pointer to the flow.
2674  * @param error Pointer to the flow error.
2675  * @returns 0 in case of success, negative value otherwise.
2676  */
2677 static int
2678 mrvl_flow_destroy(struct rte_eth_dev *dev, struct rte_flow *flow,
2679                   struct rte_flow_error *error)
2680 {
2681         struct mrvl_priv *priv = dev->data->dev_private;
2682         struct rte_flow *f;
2683         int ret;
2684
2685         LIST_FOREACH(f, &priv->flows, next) {
2686                 if (f == flow)
2687                         break;
2688         }
2689
2690         if (!flow) {
2691                 rte_flow_error_set(error, EINVAL,
2692                                    RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
2693                                    "Rule was not found");
2694                 return -rte_errno;
2695         }
2696
2697         LIST_REMOVE(f, next);
2698
2699         ret = mrvl_flow_remove(priv, flow, error);
2700         if (ret)
2701                 return ret;
2702
2703         rte_free(flow);
2704
2705         return 0;
2706 }
2707
2708 /**
2709  * DPDK flow callback called to verify given attribute, pattern and actions.
2710  *
2711  * @param dev Pointer to the device.
2712  * @param attr Pointer to the flow attribute.
2713  * @param pattern Pointer to the flow pattern.
2714  * @param actions Pointer to the flow actions.
2715  * @param error Pointer to the flow error.
2716  * @returns 0 on success, negative value otherwise.
2717  */
2718 static int
2719 mrvl_flow_validate(struct rte_eth_dev *dev,
2720                    const struct rte_flow_attr *attr,
2721                    const struct rte_flow_item pattern[],
2722                    const struct rte_flow_action actions[],
2723                    struct rte_flow_error *error)
2724 {
2725         static struct rte_flow *flow;
2726
2727         flow = mrvl_flow_create(dev, attr, pattern, actions, error);
2728         if (!flow)
2729                 return -rte_errno;
2730
2731         mrvl_flow_destroy(dev, flow, error);
2732
2733         return 0;
2734 }
2735
2736 /**
2737  * DPDK flow flush callback called when flows are to be flushed.
2738  *
2739  * @param dev Pointer to the device.
2740  * @param error Pointer to the flow error.
2741  * @returns 0 in case of success, negative value otherwise.
2742  */
2743 static int
2744 mrvl_flow_flush(struct rte_eth_dev *dev, struct rte_flow_error *error)
2745 {
2746         struct mrvl_priv *priv = dev->data->dev_private;
2747
2748         while (!LIST_EMPTY(&priv->flows)) {
2749                 struct rte_flow *flow = LIST_FIRST(&priv->flows);
2750                 int ret = mrvl_flow_remove(priv, flow, error);
2751                 if (ret)
2752                         return ret;
2753
2754                 LIST_REMOVE(flow, next);
2755                 rte_free(flow);
2756         }
2757
2758         return 0;
2759 }
2760
2761 /**
2762  * DPDK flow isolate callback called to isolate port.
2763  *
2764  * @param dev Pointer to the device.
2765  * @param enable Pass 0/1 to disable/enable port isolation.
2766  * @param error Pointer to the flow error.
2767  * @returns 0 in case of success, negative value otherwise.
2768  */
2769 static int
2770 mrvl_flow_isolate(struct rte_eth_dev *dev, int enable,
2771                   struct rte_flow_error *error)
2772 {
2773         struct mrvl_priv *priv = dev->data->dev_private;
2774
2775         if (dev->data->dev_started) {
2776                 rte_flow_error_set(error, EBUSY,
2777                                    RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
2778                                    NULL, "Port must be stopped first\n");
2779                 return -rte_errno;
2780         }
2781
2782         priv->isolated = enable;
2783
2784         return 0;
2785 }
2786
2787 const struct rte_flow_ops mrvl_flow_ops = {
2788         .validate = mrvl_flow_validate,
2789         .create = mrvl_flow_create,
2790         .destroy = mrvl_flow_destroy,
2791         .flush = mrvl_flow_flush,
2792         .isolate = mrvl_flow_isolate
2793 };
2794
2795 /**
2796  * Initialize flow resources.
2797  *
2798  * @param dev Pointer to the device.
2799  */
2800 void
2801 mrvl_flow_init(struct rte_eth_dev *dev)
2802 {
2803         struct mrvl_priv *priv = dev->data->dev_private;
2804
2805         LIST_INIT(&priv->flows);
2806 }
2807
2808 /**
2809  * Cleanup flow resources.
2810  *
2811  * @param dev Pointer to the device.
2812  */
2813 void
2814 mrvl_flow_deinit(struct rte_eth_dev *dev)
2815 {
2816         struct mrvl_priv *priv = dev->data->dev_private;
2817
2818         mrvl_flow_flush(dev, NULL);
2819
2820         if (priv->cls_tbl) {
2821                 pp2_cls_tbl_deinit(priv->cls_tbl);
2822                 priv->cls_tbl = NULL;
2823         }
2824 }