1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(C) 2021 Marvell.
5 #include "cnxk_ethdev.h"
6 #include <rte_mtr_driver.h>
8 #define NIX_MTR_COUNT_MAX 73 /* 64(leaf) + 8(mid) + 1(top) */
9 #define NIX_MTR_COUNT_PER_FLOW 3 /* 1(leaf) + 1(mid) + 1(top) */
11 #define NIX_BPF_STATS_MASK_ALL \
13 ROC_NIX_BPF_GREEN_PKT_F_PASS | ROC_NIX_BPF_GREEN_OCTS_F_PASS | \
14 ROC_NIX_BPF_GREEN_PKT_F_DROP | \
15 ROC_NIX_BPF_GREEN_OCTS_F_DROP | \
16 ROC_NIX_BPF_YELLOW_PKT_F_PASS | \
17 ROC_NIX_BPF_YELLOW_OCTS_F_PASS | \
18 ROC_NIX_BPF_YELLOW_PKT_F_DROP | \
19 ROC_NIX_BPF_YELLOW_OCTS_F_DROP | \
20 ROC_NIX_BPF_RED_PKT_F_PASS | \
21 ROC_NIX_BPF_RED_OCTS_F_PASS | \
22 ROC_NIX_BPF_RED_PKT_F_DROP | \
23 ROC_NIX_BPF_RED_OCTS_F_DROP \
26 static const enum roc_nix_bpf_level_flag lvl_map[] = {ROC_NIX_BPF_LEVEL_F_LEAF,
27 ROC_NIX_BPF_LEVEL_F_MID,
28 ROC_NIX_BPF_LEVEL_F_TOP};
30 static struct rte_mtr_capabilities mtr_capa = {
31 .n_shared_max = NIX_MTR_COUNT_PER_FLOW,
33 .shared_identical = true,
34 /* .shared_n_flows_per_mtr_max = ,*/
35 .chaining_n_mtrs_per_flow_max = NIX_MTR_COUNT_PER_FLOW,
36 .chaining_use_prev_mtr_color_supported = true,
37 .chaining_use_prev_mtr_color_enforced = true,
38 .color_aware_srtcm_rfc2697_supported = true,
39 .color_aware_trtcm_rfc2698_supported = true,
40 .color_aware_trtcm_rfc4115_supported = true,
41 .srtcm_rfc2697_byte_mode_supported = true,
42 .srtcm_rfc2697_packet_mode_supported = true,
43 .trtcm_rfc2698_byte_mode_supported = true,
44 .trtcm_rfc2698_packet_mode_supported = true,
45 .trtcm_rfc4115_byte_mode_supported = true,
46 .trtcm_rfc4115_packet_mode_supported = true,
47 .stats_mask = RTE_MTR_STATS_N_PKTS_GREEN | RTE_MTR_STATS_N_PKTS_YELLOW |
48 RTE_MTR_STATS_N_PKTS_RED | RTE_MTR_STATS_N_PKTS_DROPPED |
49 RTE_MTR_STATS_N_BYTES_GREEN |
50 RTE_MTR_STATS_N_BYTES_YELLOW | RTE_MTR_STATS_N_BYTES_RED |
51 RTE_MTR_STATS_N_BYTES_DROPPED};
53 static struct cnxk_meter_node *
54 nix_mtr_find(struct cnxk_eth_dev *dev, uint32_t meter_id)
56 struct cnxk_mtr *fms = &dev->mtr;
57 struct cnxk_meter_node *fm;
59 TAILQ_FOREACH(fm, fms, next)
60 if (meter_id == fm->id)
65 static struct cnxk_mtr_profile_node *
66 nix_mtr_profile_find(struct cnxk_eth_dev *dev, uint32_t profile_id)
68 struct cnxk_mtr_profiles *fmps = &dev->mtr_profiles;
69 struct cnxk_mtr_profile_node *fmp;
71 TAILQ_FOREACH(fmp, fmps, next)
72 if (profile_id == fmp->id)
78 static struct cnxk_mtr_policy_node *
79 nix_mtr_policy_find(struct cnxk_eth_dev *dev, uint32_t meter_policy_id)
81 struct cnxk_mtr_policy *fmps = &dev->mtr_policy;
82 struct cnxk_mtr_policy_node *fmp;
84 TAILQ_FOREACH(fmp, fmps, next)
85 if (meter_policy_id == fmp->id)
91 nix_mtr_profile_validate(struct cnxk_eth_dev *dev, uint32_t profile_id,
92 struct rte_mtr_meter_profile *profile,
93 struct rte_mtr_error *error)
100 return -rte_mtr_error_set(error, EINVAL,
101 RTE_MTR_ERROR_TYPE_METER_PROFILE,
102 NULL, "Meter profile is null.");
104 if (profile_id == UINT32_MAX)
105 return -rte_mtr_error_set(error, EINVAL,
106 RTE_MTR_ERROR_TYPE_METER_PROFILE_ID,
107 NULL, "Meter profile id not valid.");
109 switch (profile->alg) {
110 case RTE_MTR_SRTCM_RFC2697:
111 if (profile->srtcm_rfc2697.cir > mtr_capa.meter_rate_max)
112 rc = -rte_mtr_error_set(error, EINVAL,
113 RTE_MTR_ERROR_TYPE_METER_PROFILE, NULL,
114 "CIR exceeds max meter rate");
116 if (profile->srtcm_rfc2697.cbs > NIX_BPF_BURST_MAX)
117 rc = -rte_mtr_error_set(error, EINVAL,
118 RTE_MTR_ERROR_TYPE_METER_PROFILE, NULL,
119 "CBS exceeds max meter burst size");
121 if (profile->srtcm_rfc2697.ebs > NIX_BPF_BURST_MAX)
122 rc = -rte_mtr_error_set(error, EINVAL,
123 RTE_MTR_ERROR_TYPE_METER_PROFILE, NULL,
124 "EBS exceeds max meter burst size");
127 case RTE_MTR_TRTCM_RFC2698:
128 if (profile->trtcm_rfc2698.cir > mtr_capa.meter_rate_max)
129 rc = -rte_mtr_error_set(error, EINVAL,
130 RTE_MTR_ERROR_TYPE_METER_PROFILE, NULL,
131 "CIR exceeds max meter rate");
133 if (profile->trtcm_rfc2698.pir > mtr_capa.meter_rate_max)
134 rc = -rte_mtr_error_set(error, EINVAL,
135 RTE_MTR_ERROR_TYPE_METER_PROFILE, NULL,
136 "PIR exceeds max meter rate");
138 if (profile->trtcm_rfc2698.cbs > NIX_BPF_BURST_MAX)
139 rc = -rte_mtr_error_set(error, EINVAL,
140 RTE_MTR_ERROR_TYPE_METER_PROFILE, NULL,
141 "CBS exceeds max meter burst size");
143 if (profile->trtcm_rfc2698.pbs > NIX_BPF_BURST_MAX)
144 rc = -rte_mtr_error_set(error, EINVAL,
145 RTE_MTR_ERROR_TYPE_METER_PROFILE, NULL,
146 "PBS exceeds max meter burst size");
149 case RTE_MTR_TRTCM_RFC4115:
150 if ((profile->trtcm_rfc4115.cir + profile->trtcm_rfc4115.eir) >
151 mtr_capa.meter_rate_max)
152 rc = -rte_mtr_error_set(error, EINVAL,
153 RTE_MTR_ERROR_TYPE_METER_PROFILE, NULL,
154 "PIR + EIR exceeds max rate");
156 if (profile->trtcm_rfc4115.cbs > NIX_BPF_BURST_MAX)
157 rc = -rte_mtr_error_set(error, EINVAL,
158 RTE_MTR_ERROR_TYPE_METER_PROFILE, NULL,
159 "CBS exceeds max meter burst size");
161 if (profile->trtcm_rfc4115.ebs > NIX_BPF_BURST_MAX)
162 rc = -rte_mtr_error_set(error, EINVAL,
163 RTE_MTR_ERROR_TYPE_METER_PROFILE, NULL,
164 "PBS exceeds max meter burst size");
168 rc = -rte_mtr_error_set(error, EINVAL,
169 RTE_MTR_ERROR_TYPE_METER_PROFILE, NULL,
178 cnxk_nix_mtr_capabilities_get(struct rte_eth_dev *dev,
179 struct rte_mtr_capabilities *capa,
180 struct rte_mtr_error *error)
182 uint8_t lvl_mask = ROC_NIX_BPF_LEVEL_F_LEAF | ROC_NIX_BPF_LEVEL_F_MID |
183 ROC_NIX_BPF_LEVEL_F_TOP;
184 struct cnxk_eth_dev *eth_dev = cnxk_eth_pmd_priv(dev);
185 uint16_t count[ROC_NIX_BPF_LEVEL_MAX] = {0};
186 struct roc_nix *nix = ð_dev->nix;
193 return -rte_mtr_error_set(error, EINVAL,
194 RTE_MTR_ERROR_TYPE_MTR_PARAMS, NULL,
195 "NULL input parameter");
197 rc = roc_nix_bpf_count_get(nix, lvl_mask, count);
201 for (i = 0; i < ROC_NIX_BPF_LEVEL_MAX; i++)
202 mtr_capa.n_max += count[i];
204 mtr_capa.meter_srtcm_rfc2697_n_max = mtr_capa.n_max;
205 mtr_capa.meter_trtcm_rfc2698_n_max = mtr_capa.n_max;
206 mtr_capa.meter_trtcm_rfc4115_n_max = mtr_capa.n_max;
207 mtr_capa.meter_policy_n_max = mtr_capa.n_max;
209 rc = roc_nix_bpf_timeunit_get(nix, &time_unit);
213 mtr_capa.meter_rate_max =
214 NIX_BPF_RATE(time_unit, NIX_BPF_MAX_RATE_EXPONENT,
215 NIX_BPF_MAX_RATE_MANTISSA, 0) /
223 cnxk_nix_mtr_profile_add(struct rte_eth_dev *eth_dev, uint32_t profile_id,
224 struct rte_mtr_meter_profile *profile,
225 struct rte_mtr_error *error)
227 struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
228 struct cnxk_mtr_profiles *fmps = &dev->mtr_profiles;
229 struct cnxk_mtr_profile_node *fmp;
232 /* Check input params. */
233 ret = nix_mtr_profile_validate(dev, profile_id, profile, error);
237 fmp = nix_mtr_profile_find(dev, profile_id);
239 return -rte_mtr_error_set(error, EEXIST,
240 RTE_MTR_ERROR_TYPE_METER_PROFILE_ID,
241 NULL, "Profile already exist");
244 fmp = plt_zmalloc(sizeof(struct cnxk_mtr_profile_node), ROC_ALIGN);
246 return -rte_mtr_error_set(error, ENOMEM,
247 RTE_MTR_ERROR_TYPE_UNSPECIFIED, NULL,
248 "Meter profile memory "
251 fmp->id = profile_id;
252 fmp->profile = *profile;
254 TAILQ_INSERT_TAIL(fmps, fmp, next);
260 cnxk_nix_mtr_profile_delete(struct rte_eth_dev *eth_dev, uint32_t profile_id,
261 struct rte_mtr_error *error)
263 struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
264 struct cnxk_mtr_profile_node *fmp;
266 if (profile_id == UINT32_MAX)
267 return -rte_mtr_error_set(error, EINVAL,
268 RTE_MTR_ERROR_TYPE_METER_PROFILE_ID,
269 NULL, "Meter profile id not valid.");
271 fmp = nix_mtr_profile_find(dev, profile_id);
273 return -rte_mtr_error_set(error, ENOENT,
274 RTE_MTR_ERROR_TYPE_METER_PROFILE_ID,
276 "Meter profile is invalid.");
279 return -rte_mtr_error_set(error, EBUSY,
280 RTE_MTR_ERROR_TYPE_METER_PROFILE_ID,
281 NULL, "Meter profile is in use.");
283 TAILQ_REMOVE(&dev->mtr_profiles, fmp, next);
289 cnxk_nix_mtr_policy_validate(struct rte_eth_dev *dev,
290 struct rte_mtr_meter_policy_params *policy,
291 struct rte_mtr_error *error)
293 static const char *const action_color[] = {"Green", "Yellow", "Red"};
294 bool supported[RTE_COLORS] = {false, false, false};
295 const struct rte_flow_action *action;
302 return 0; /* Nothing to be validated */
304 for (i = 0; i < RTE_COLORS; i++) {
305 if (policy->actions[i]) {
306 for (action = policy->actions[i];
307 action->type != RTE_FLOW_ACTION_TYPE_END;
309 if (action->type == RTE_FLOW_ACTION_TYPE_METER)
312 if (action->type == RTE_FLOW_ACTION_TYPE_DROP)
315 if (action->type == RTE_FLOW_ACTION_TYPE_VOID)
320 "%s action is not valid",
322 return -rte_mtr_error_set(error,
324 RTE_MTR_ERROR_TYPE_METER_POLICY, NULL,
329 sprintf(message, "%s action is null", action_color[i]);
330 return -rte_mtr_error_set(error, EINVAL,
331 RTE_MTR_ERROR_TYPE_METER_POLICY, NULL,
340 cnxk_fill_policy_actions(struct cnxk_mtr_policy_node *fmp,
341 struct rte_mtr_meter_policy_params *policy)
344 const struct rte_flow_action_meter *mtr;
345 const struct rte_flow_action *action;
348 for (i = 0; i < RTE_COLORS; i++) {
349 if (policy->actions[i]) {
350 for (action = policy->actions[i];
351 action->type != RTE_FLOW_ACTION_TYPE_END;
354 RTE_FLOW_ACTION_TYPE_METER) {
355 fmp->actions[i].action_fate =
358 rte_flow_action_meter *)
360 fmp->actions[i].mtr_id = mtr->mtr_id;
363 if (action->type == RTE_FLOW_ACTION_TYPE_DROP) {
364 fmp->actions[i].action_fate =
373 cnxk_nix_mtr_policy_add(struct rte_eth_dev *eth_dev, uint32_t policy_id,
374 struct rte_mtr_meter_policy_params *policy,
375 struct rte_mtr_error *error)
377 struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
378 struct cnxk_mtr_policy *fmps = &dev->mtr_policy;
379 struct cnxk_mtr_policy_node *fmp;
382 fmp = nix_mtr_policy_find(dev, policy_id);
384 return -rte_mtr_error_set(error, EEXIST,
385 RTE_MTR_ERROR_TYPE_METER_POLICY_ID,
386 NULL, "Policy already exist");
389 fmp = plt_zmalloc(sizeof(struct cnxk_mtr_policy_node), ROC_ALIGN);
391 return -rte_mtr_error_set(error, ENOMEM,
392 RTE_MTR_ERROR_TYPE_UNSPECIFIED, NULL,
393 "Memory allocation failure");
395 rc = cnxk_nix_mtr_policy_validate(eth_dev, policy, error);
401 cnxk_fill_policy_actions(fmp, policy);
402 TAILQ_INSERT_TAIL(fmps, fmp, next);
411 cnxk_nix_mtr_policy_delete(struct rte_eth_dev *eth_dev, uint32_t policy_id,
412 struct rte_mtr_error *error)
414 struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
415 struct cnxk_mtr_policy_node *fmp;
417 fmp = nix_mtr_policy_find(dev, policy_id);
419 return -rte_mtr_error_set(error, ENOENT,
420 RTE_MTR_ERROR_TYPE_METER_POLICY_ID,
421 NULL, "No policy found");
425 return -rte_mtr_error_set(error, EBUSY,
426 RTE_MTR_ERROR_TYPE_METER_POLICY_ID,
427 NULL, "Meter policy is in use.");
429 TAILQ_REMOVE(&dev->mtr_policy, fmp, next);
436 cnxk_nix_mtr_create(struct rte_eth_dev *eth_dev, uint32_t mtr_id,
437 struct rte_mtr_params *params, int shared,
438 struct rte_mtr_error *error)
440 struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
441 struct cnxk_mtr_profile_node *profile;
442 struct cnxk_mtr_policy_node *policy;
443 struct cnxk_mtr *fm = &dev->mtr;
444 struct cnxk_meter_node *mtr;
447 RTE_SET_USED(shared);
450 return -rte_mtr_error_set(error, ENOENT,
451 RTE_MTR_ERROR_TYPE_MTR_PARAMS, NULL,
452 "Meter params are invalid.");
454 profile = nix_mtr_profile_find(dev, params->meter_profile_id);
456 return -rte_mtr_error_set(error, ENOENT,
457 RTE_MTR_ERROR_TYPE_METER_PROFILE_ID,
458 ¶ms->meter_profile_id,
459 "Meter profile is invalid.");
461 policy = nix_mtr_policy_find(dev, params->meter_policy_id);
463 return -rte_mtr_error_set(error, ENOENT,
464 RTE_MTR_ERROR_TYPE_METER_POLICY_ID,
465 ¶ms->meter_policy_id,
466 "Meter policy is invalid.");
468 mtr = nix_mtr_find(dev, mtr_id);
470 return -rte_mtr_error_set(error, EEXIST,
471 RTE_MTR_ERROR_TYPE_MTR_ID, NULL,
472 "Meter already exist");
475 mtr = plt_zmalloc(sizeof(struct cnxk_meter_node), ROC_ALIGN);
477 return -rte_mtr_error_set(error, ENOMEM,
478 RTE_MTR_ERROR_TYPE_UNSPECIFIED, NULL,
479 "Meter memory alloc failed.");
483 mtr->profile = profile;
484 mtr->policy = policy;
485 mtr->params = *params;
486 mtr->bpf_id = ROC_NIX_BPF_ID_INVALID;
488 for (i = 0; i < MAX_PRV_MTR_NODES; i++)
489 mtr->prev_id[i] = ROC_NIX_BPF_ID_INVALID;
491 mtr->next_id = ROC_NIX_BPF_ID_INVALID;
492 mtr->is_next = false;
493 mtr->level = ROC_NIX_BPF_LEVEL_IDX_INVALID;
495 if (params->dscp_table) {
496 mtr->params.dscp_table =
497 plt_zmalloc(ROC_NIX_BPF_PRE_COLOR_MAX, ROC_ALIGN);
498 if (mtr->params.dscp_table == NULL) {
500 return -rte_mtr_error_set(error, ENOMEM,
501 RTE_MTR_ERROR_TYPE_UNSPECIFIED,
502 NULL, "Memory alloc failed.");
505 for (i = 0; i < ROC_NIX_BPF_PRE_COLOR_MAX; i++)
506 mtr->params.dscp_table[i] = params->dscp_table[i];
511 TAILQ_INSERT_TAIL(fm, mtr, next);
516 cnxk_nix_mtr_destroy(struct rte_eth_dev *eth_dev, uint32_t mtr_id,
517 struct rte_mtr_error *error)
519 struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
520 struct roc_nix_bpf_objs profs = {0};
521 struct cnxk_mtr *fm = &dev->mtr;
522 struct roc_nix *nix = &dev->nix;
523 struct cnxk_meter_node *mtr;
524 struct cnxk_meter_node *mid_mtr;
525 struct cnxk_meter_node *top_mtr;
528 mtr = nix_mtr_find(dev, mtr_id);
530 return -rte_mtr_error_set(error, ENOENT,
531 RTE_MTR_ERROR_TYPE_MTR_ID, &mtr_id,
532 "Meter id is invalid.");
536 return -rte_mtr_error_set(error, EADDRINUSE,
537 RTE_MTR_ERROR_TYPE_MTR_ID, &mtr_id,
541 switch (lvl_map[mtr->level]) {
542 case ROC_NIX_BPF_LEVEL_F_LEAF:
544 rc = roc_nix_bpf_connect(nix, ROC_NIX_BPF_LEVEL_F_LEAF,
546 ROC_NIX_BPF_ID_INVALID);
549 case ROC_NIX_BPF_LEVEL_F_MID:
550 while ((mtr->prev_cnt) + 1) {
552 nix_mtr_find(dev, mtr->prev_id[mtr->prev_cnt]);
553 rc = roc_nix_bpf_connect(nix, ROC_NIX_BPF_LEVEL_F_LEAF,
555 ROC_NIX_BPF_ID_INVALID);
559 rc = roc_nix_bpf_connect(nix, ROC_NIX_BPF_LEVEL_F_MID,
561 ROC_NIX_BPF_ID_INVALID);
564 case ROC_NIX_BPF_LEVEL_F_TOP:
565 while (mtr->prev_cnt) {
567 nix_mtr_find(dev, mtr->prev_id[mtr->prev_cnt]);
568 rc = roc_nix_bpf_connect(nix, ROC_NIX_BPF_LEVEL_F_MID,
570 ROC_NIX_BPF_ID_INVALID);
575 return -rte_mtr_error_set(error, EINVAL,
576 RTE_MTR_ERROR_TYPE_MTR_ID, NULL,
577 "Invalid meter level");
583 profs.level = mtr->level;
585 profs.ids[0] = mtr->bpf_id;
586 rc = roc_nix_bpf_free(nix, &profs, 1);
590 mtr->policy->ref_cnt--;
591 mtr->profile->ref_cnt--;
592 TAILQ_REMOVE(fm, mtr, next);
593 plt_free(mtr->params.dscp_table);
601 cnxk_nix_mtr_enable(struct rte_eth_dev *eth_dev, uint32_t mtr_id,
602 struct rte_mtr_error *error)
604 struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
605 struct roc_nix *nix = &dev->nix;
606 struct cnxk_meter_node *mtr;
607 struct roc_nix_rq *rq;
611 mtr = nix_mtr_find(dev, mtr_id);
613 return -rte_mtr_error_set(error, ENOENT,
614 RTE_MTR_ERROR_TYPE_MTR_ID, NULL,
615 "Meter id is invalid.");
621 for (i = 0; i < mtr->rq_num; i++) {
622 rq = &dev->rqs[mtr->rq_id[i]];
623 rc |= roc_nix_bpf_ena_dis(nix, mtr->bpf_id, rq, true);
630 cnxk_nix_mtr_disable(struct rte_eth_dev *eth_dev, uint32_t mtr_id,
631 struct rte_mtr_error *error)
633 struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
634 struct roc_nix *nix = &dev->nix;
635 struct cnxk_meter_node *mtr;
636 struct roc_nix_rq *rq;
640 mtr = nix_mtr_find(dev, mtr_id);
642 return -rte_mtr_error_set(error, ENOENT,
643 RTE_MTR_ERROR_TYPE_MTR_ID, NULL,
644 "Meter id is invalid.");
650 for (i = 0; i < mtr->rq_num; i++) {
651 rq = &dev->rqs[mtr->rq_id[i]];
652 rc |= roc_nix_bpf_ena_dis(nix, mtr->bpf_id, rq, false);
659 cnxk_nix_mtr_dscp_table_update(struct rte_eth_dev *eth_dev, uint32_t mtr_id,
660 enum rte_color *dscp_table,
661 struct rte_mtr_error *error)
663 enum roc_nix_bpf_color nix_dscp_tbl[ROC_NIX_BPF_PRE_COLOR_MAX];
664 enum roc_nix_bpf_color color_map[] = {ROC_NIX_BPF_COLOR_GREEN,
665 ROC_NIX_BPF_COLOR_YELLOW,
666 ROC_NIX_BPF_COLOR_RED};
667 struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
668 struct roc_nix_bpf_precolor table;
669 struct roc_nix *nix = &dev->nix;
670 struct cnxk_meter_node *mtr;
673 mtr = nix_mtr_find(dev, mtr_id);
675 return -rte_mtr_error_set(error, ENOENT,
676 RTE_MTR_ERROR_TYPE_MTR_ID, NULL,
677 "Meter object not found");
681 for (i = 0; i < ROC_NIX_BPF_PRE_COLOR_MAX; i++)
682 nix_dscp_tbl[i] = ROC_NIX_BPF_COLOR_GREEN;
684 for (i = 0; i < ROC_NIX_BPF_PRE_COLOR_MAX; i++)
685 nix_dscp_tbl[i] = color_map[dscp_table[i]];
688 table.count = ROC_NIX_BPF_PRE_COLOR_MAX;
689 table.mode = ROC_NIX_BPF_PC_MODE_DSCP_OUTER;
690 for (i = 0; i < ROC_NIX_BPF_PRE_COLOR_MAX; i++)
691 table.color[i] = nix_dscp_tbl[i];
693 rc = roc_nix_bpf_pre_color_tbl_setup(nix, mtr->bpf_id,
694 lvl_map[mtr->level], &table);
696 rte_mtr_error_set(error, rc, RTE_MTR_ERROR_TYPE_UNSPECIFIED,
701 for (i = 0; i < ROC_NIX_BPF_PRE_COLOR_MAX; i++)
702 dev->precolor_tbl[i] = nix_dscp_tbl[i];
709 cnxk_nix_mtr_stats_update(struct rte_eth_dev *eth_dev, uint32_t mtr_id,
710 uint64_t stats_mask, struct rte_mtr_error *error)
712 struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
713 struct cnxk_meter_node *mtr;
716 return -rte_mtr_error_set(error, EINVAL,
717 RTE_MTR_ERROR_TYPE_MTR_PARAMS, NULL,
718 "no bit is set to stats mask");
720 mtr = nix_mtr_find(dev, mtr_id);
722 return -rte_mtr_error_set(error, ENOENT,
723 RTE_MTR_ERROR_TYPE_MTR_ID, NULL,
724 "Meter object not found");
727 mtr->params.stats_mask = stats_mask;
732 cnxk_nix_mtr_stats_read(struct rte_eth_dev *eth_dev, uint32_t mtr_id,
733 struct rte_mtr_stats *stats, uint64_t *stats_mask,
734 int clear, struct rte_mtr_error *error)
736 uint8_t yellow_pkt_pass, yellow_octs_pass, yellow_pkt_drop;
737 uint8_t green_octs_drop, yellow_octs_drop, red_octs_drop;
738 uint8_t green_pkt_pass, green_octs_pass, green_pkt_drop;
739 struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
740 uint8_t red_pkt_pass, red_octs_pass, red_pkt_drop;
741 uint64_t bpf_stats[ROC_NIX_BPF_STATS_MAX] = {0};
742 uint64_t mask = NIX_BPF_STATS_MASK_ALL;
743 struct roc_nix *nix = &dev->nix;
744 struct cnxk_meter_node *mtr;
748 return -rte_mtr_error_set(error, EINVAL,
749 RTE_MTR_ERROR_TYPE_MTR_PARAMS, NULL,
750 "stats pointer is NULL");
752 mtr = nix_mtr_find(dev, mtr_id);
754 return -rte_mtr_error_set(error, ENOENT,
755 RTE_MTR_ERROR_TYPE_MTR_ID, NULL,
756 "Meter object not found");
759 rc = roc_nix_bpf_stats_read(nix, mtr->bpf_id, mask, lvl_map[mtr->level],
762 rte_mtr_error_set(error, rc, RTE_MTR_ERROR_TYPE_UNSPECIFIED,
767 green_pkt_pass = roc_nix_bpf_stats_to_idx(ROC_NIX_BPF_GREEN_PKT_F_PASS);
769 roc_nix_bpf_stats_to_idx(ROC_NIX_BPF_GREEN_OCTS_F_PASS);
770 green_pkt_drop = roc_nix_bpf_stats_to_idx(ROC_NIX_BPF_GREEN_PKT_F_DROP);
772 roc_nix_bpf_stats_to_idx(ROC_NIX_BPF_GREEN_OCTS_F_DROP);
774 roc_nix_bpf_stats_to_idx(ROC_NIX_BPF_YELLOW_PKT_F_PASS);
776 roc_nix_bpf_stats_to_idx(ROC_NIX_BPF_YELLOW_OCTS_F_PASS);
778 roc_nix_bpf_stats_to_idx(ROC_NIX_BPF_YELLOW_PKT_F_DROP);
780 roc_nix_bpf_stats_to_idx(ROC_NIX_BPF_YELLOW_OCTS_F_DROP);
781 red_pkt_pass = roc_nix_bpf_stats_to_idx(ROC_NIX_BPF_RED_PKT_F_PASS);
782 red_octs_pass = roc_nix_bpf_stats_to_idx(ROC_NIX_BPF_RED_OCTS_F_PASS);
783 red_pkt_drop = roc_nix_bpf_stats_to_idx(ROC_NIX_BPF_RED_PKT_F_DROP);
784 red_octs_drop = roc_nix_bpf_stats_to_idx(ROC_NIX_BPF_RED_OCTS_F_DROP);
786 if (mtr->params.stats_mask & RTE_MTR_STATS_N_PKTS_GREEN)
787 stats->n_pkts[RTE_COLOR_GREEN] = bpf_stats[green_pkt_pass];
789 if (mtr->params.stats_mask & RTE_MTR_STATS_N_PKTS_YELLOW)
790 stats->n_pkts[RTE_COLOR_YELLOW] = bpf_stats[yellow_pkt_pass];
792 if (mtr->params.stats_mask & RTE_MTR_STATS_N_PKTS_RED)
793 stats->n_pkts[RTE_COLOR_RED] = bpf_stats[red_pkt_pass];
795 if (mtr->params.stats_mask & RTE_MTR_STATS_N_BYTES_GREEN)
796 stats->n_bytes[RTE_COLOR_GREEN] = bpf_stats[green_octs_pass];
798 if (mtr->params.stats_mask & RTE_MTR_STATS_N_BYTES_YELLOW)
799 stats->n_bytes[RTE_COLOR_YELLOW] = bpf_stats[yellow_octs_pass];
801 if (mtr->params.stats_mask & RTE_MTR_STATS_N_BYTES_RED)
802 stats->n_bytes[RTE_COLOR_RED] = bpf_stats[red_octs_pass];
804 if (mtr->params.stats_mask & RTE_MTR_STATS_N_PKTS_DROPPED)
805 stats->n_pkts_dropped = bpf_stats[green_pkt_drop] +
806 bpf_stats[yellow_pkt_drop] +
807 bpf_stats[red_pkt_drop];
809 if (mtr->params.stats_mask & RTE_MTR_STATS_N_BYTES_DROPPED)
810 stats->n_bytes_dropped = bpf_stats[green_octs_drop] +
811 bpf_stats[yellow_octs_drop] +
812 bpf_stats[red_octs_drop];
815 *stats_mask = mtr->params.stats_mask;
818 rc = roc_nix_bpf_stats_reset(nix, mtr->bpf_id, mask,
819 lvl_map[mtr->level]);
821 rte_mtr_error_set(error, rc,
822 RTE_MTR_ERROR_TYPE_UNSPECIFIED, NULL,
832 const struct rte_mtr_ops nix_mtr_ops = {
833 .capabilities_get = cnxk_nix_mtr_capabilities_get,
834 .meter_profile_add = cnxk_nix_mtr_profile_add,
835 .meter_profile_delete = cnxk_nix_mtr_profile_delete,
836 .meter_policy_validate = cnxk_nix_mtr_policy_validate,
837 .meter_policy_add = cnxk_nix_mtr_policy_add,
838 .meter_policy_delete = cnxk_nix_mtr_policy_delete,
839 .create = cnxk_nix_mtr_create,
840 .destroy = cnxk_nix_mtr_destroy,
841 .meter_enable = cnxk_nix_mtr_enable,
842 .meter_disable = cnxk_nix_mtr_disable,
843 .meter_dscp_table_update = cnxk_nix_mtr_dscp_table_update,
844 .stats_update = cnxk_nix_mtr_stats_update,
845 .stats_read = cnxk_nix_mtr_stats_read,
849 cnxk_nix_mtr_ops_get(struct rte_eth_dev *dev, void *ops)
853 *(const void **)ops = &nix_mtr_ops;
858 nix_mtr_validate(struct rte_eth_dev *eth_dev, uint32_t id)
860 struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
861 struct cnxk_mtr_profile_node *profile;
862 struct cnxk_mtr_policy_node *policy;
863 struct cnxk_meter_node *mtr;
865 mtr = nix_mtr_find(dev, id);
869 profile = nix_mtr_profile_find(dev, mtr->params.meter_profile_id);
873 policy = nix_mtr_policy_find(dev, mtr->params.meter_policy_id);
881 nix_mtr_policy_act_get(struct rte_eth_dev *eth_dev, uint32_t id,
882 struct cnxk_mtr_policy_node **policy_act)
884 struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
885 struct cnxk_mtr_policy_node *policy;
886 struct cnxk_meter_node *mtr;
888 mtr = nix_mtr_find(dev, id);
892 policy = nix_mtr_policy_find(dev, mtr->params.meter_policy_id);
896 *policy_act = policy;
902 nix_mtr_rq_update(struct rte_eth_dev *eth_dev, uint32_t id, uint32_t queue_num,
903 const uint16_t *queue)
905 struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
906 struct cnxk_meter_node *mtr;
909 mtr = nix_mtr_find(dev, id);
913 mtr->rq_id = plt_zmalloc(queue_num * sizeof(uint32_t), ROC_ALIGN);
914 if (mtr->rq_id == NULL)
917 mtr->rq_num = queue_num;
918 for (i = 0; i < queue_num; i++)
919 mtr->rq_id[i] = queue[i];
925 nix_mtr_chain_reset(struct rte_eth_dev *eth_dev, uint32_t cur_id)
927 struct cnxk_meter_node *mtr[ROC_NIX_BPF_LEVEL_MAX] = {0};
928 struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
929 uint32_t mtr_id = cur_id;
932 for (i = 0; i < ROC_NIX_BPF_LEVEL_MAX; i++) {
933 mtr[i] = nix_mtr_find(dev, mtr_id);
935 mtr_id = mtr[i]->next_id;
937 for (i = 0; i < ROC_NIX_BPF_LEVEL_MAX; i++) {
939 for (j = 0; j < MAX_PRV_MTR_NODES; j++)
940 mtr[i]->prev_id[i] = ROC_NIX_BPF_ID_INVALID;
941 mtr[i]->level = ROC_NIX_BPF_LEVEL_IDX_INVALID;
942 mtr[i]->next_id = ROC_NIX_BPF_ID_INVALID;
943 mtr[i]->is_next = false;
944 mtr[i]->prev_cnt = 0;
951 nix_mtr_chain_update(struct rte_eth_dev *eth_dev, uint32_t cur_id,
952 uint32_t prev_id, uint32_t next_id)
954 struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
955 struct cnxk_meter_node *mtr;
957 mtr = nix_mtr_find(dev, cur_id);
961 switch (lvl_map[mtr->level]) {
962 case ROC_NIX_BPF_LEVEL_F_LEAF:
963 mtr->prev_id[mtr->prev_cnt] = ROC_NIX_BPF_ID_INVALID;
964 mtr->next_id = next_id;
967 case ROC_NIX_BPF_LEVEL_F_MID:
968 mtr->prev_id[mtr->prev_cnt] = prev_id;
969 mtr->next_id = next_id;
972 case ROC_NIX_BPF_LEVEL_F_TOP:
973 mtr->prev_id[mtr->prev_cnt] = prev_id;
974 mtr->next_id = ROC_NIX_BPF_ID_INVALID;
975 mtr->is_next = false;
978 plt_err("Invalid meter level");
985 struct cnxk_meter_node *
986 nix_get_mtr(struct rte_eth_dev *eth_dev, uint32_t id)
988 struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
989 struct cnxk_meter_node *mtr;
991 mtr = nix_mtr_find(dev, id);
999 nix_mtr_level_update(struct rte_eth_dev *eth_dev, uint32_t id, uint32_t level)
1001 struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
1002 struct cnxk_meter_node *mtr;
1004 mtr = nix_mtr_find(dev, id);
1013 nix_mtr_config_map(struct cnxk_meter_node *mtr, struct roc_nix_bpf_cfg *cfg)
1015 enum roc_nix_bpf_algo alg_map[] = {
1016 ROC_NIX_BPF_ALGO_NONE, ROC_NIX_BPF_ALGO_2697,
1017 ROC_NIX_BPF_ALGO_2698, ROC_NIX_BPF_ALGO_4115};
1018 struct cnxk_mtr_profile_node *profile = mtr->profile;
1019 struct cnxk_mtr_policy_node *policy = mtr->policy;
1021 cfg->alg = alg_map[profile->profile.alg];
1022 cfg->lmode = profile->profile.packet_mode;
1025 case ROC_NIX_BPF_ALGO_2697:
1026 cfg->algo2697.cir = profile->profile.srtcm_rfc2697.cir * 8;
1027 cfg->algo2697.cbs = profile->profile.srtcm_rfc2697.cbs;
1028 cfg->algo2697.ebs = profile->profile.srtcm_rfc2697.ebs;
1030 case ROC_NIX_BPF_ALGO_2698:
1031 cfg->algo2698.cir = profile->profile.trtcm_rfc2698.cir * 8;
1032 cfg->algo2698.pir = profile->profile.trtcm_rfc2698.pir * 8;
1033 cfg->algo2698.cbs = profile->profile.trtcm_rfc2698.cbs;
1034 cfg->algo2698.pbs = profile->profile.trtcm_rfc2698.pbs;
1036 case ROC_NIX_BPF_ALGO_4115:
1037 cfg->algo4115.cir = profile->profile.trtcm_rfc4115.cir * 8;
1038 cfg->algo4115.eir = profile->profile.trtcm_rfc4115.eir * 8;
1039 cfg->algo4115.cbs = profile->profile.trtcm_rfc4115.cbs;
1040 cfg->algo4115.ebs = profile->profile.trtcm_rfc4115.ebs;
1046 cfg->action[ROC_NIX_BPF_COLOR_GREEN] = ROC_NIX_BPF_ACTION_PASS;
1047 cfg->action[ROC_NIX_BPF_COLOR_YELLOW] = ROC_NIX_BPF_ACTION_PASS;
1048 cfg->action[ROC_NIX_BPF_COLOR_RED] = ROC_NIX_BPF_ACTION_PASS;
1050 if (policy->actions[RTE_COLOR_GREEN].action_fate ==
1051 RTE_FLOW_ACTION_TYPE_DROP)
1052 cfg->action[ROC_NIX_BPF_COLOR_GREEN] = ROC_NIX_BPF_ACTION_DROP;
1054 if (policy->actions[RTE_COLOR_YELLOW].action_fate ==
1055 RTE_FLOW_ACTION_TYPE_DROP)
1056 cfg->action[ROC_NIX_BPF_COLOR_YELLOW] = ROC_NIX_BPF_ACTION_DROP;
1058 if (policy->actions[RTE_COLOR_RED].action_fate ==
1059 RTE_FLOW_ACTION_TYPE_DROP)
1060 cfg->action[ROC_NIX_BPF_COLOR_RED] = ROC_NIX_BPF_ACTION_DROP;
1064 nix_dscp_table_map(struct cnxk_meter_node *mtr,
1065 struct roc_nix_bpf_precolor *tbl)
1067 enum roc_nix_bpf_color color_map[] = {ROC_NIX_BPF_COLOR_GREEN,
1068 ROC_NIX_BPF_COLOR_YELLOW,
1069 ROC_NIX_BPF_COLOR_RED};
1072 tbl->count = ROC_NIX_BPF_PRE_COLOR_MAX;
1073 tbl->mode = ROC_NIX_BPF_PC_MODE_DSCP_OUTER;
1075 for (i = 0; i < ROC_NIX_BPF_PRE_COLOR_MAX; i++)
1076 tbl->color[i] = ROC_NIX_BPF_COLOR_GREEN;
1078 if (mtr->params.dscp_table) {
1079 for (i = 0; i < ROC_NIX_BPF_PRE_COLOR_MAX; i++)
1080 tbl->color[i] = color_map[mtr->params.dscp_table[i]];
1085 nix_mtr_destroy(struct rte_eth_dev *eth_dev, uint32_t id,
1086 struct rte_mtr_error *error)
1088 return cnxk_nix_mtr_destroy(eth_dev, id, error);
1092 nix_mtr_connect(struct rte_eth_dev *eth_dev, uint32_t id)
1094 enum roc_nix_bpf_level_flag lvl_flag = ROC_NIX_BPF_LEVEL_IDX_INVALID;
1095 struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
1096 struct cnxk_meter_node *base_mtr, *next_mtr;
1097 struct roc_nix *nix = &dev->nix;
1098 uint32_t cur_mtr_id = id;
1101 for (i = 0; i < ROC_NIX_BPF_LEVEL_MAX; i++) {
1102 base_mtr = nix_mtr_find(dev, cur_mtr_id);
1104 lvl_flag = lvl_map[base_mtr->level];
1105 if (base_mtr->is_next) {
1106 next_mtr = nix_mtr_find(dev, base_mtr->next_id);
1108 if (!base_mtr->is_used) {
1109 rc = roc_nix_bpf_connect(nix,
1117 cur_mtr_id = base_mtr->next_id;
1125 nix_mtr_configure(struct rte_eth_dev *eth_dev, uint32_t id)
1127 struct cnxk_meter_node *mtr[ROC_NIX_BPF_LEVEL_MAX] = {0};
1128 struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
1129 struct roc_nix_bpf_objs profs[ROC_NIX_BPF_LEVEL_MAX];
1130 uint8_t idx0 = ROC_NIX_BPF_LEVEL_IDX_INVALID;
1131 uint8_t idx1 = ROC_NIX_BPF_LEVEL_IDX_INVALID;
1132 uint8_t idx2 = ROC_NIX_BPF_LEVEL_IDX_INVALID;
1133 uint16_t per_lvl_cnt[ROC_NIX_BPF_LEVEL_MAX];
1134 int num_mtr[ROC_NIX_BPF_LEVEL_MAX] = {0};
1135 struct roc_nix *nix = &dev->nix;
1136 struct roc_nix_bpf_precolor tbl;
1137 struct roc_nix_bpf_cfg cfg;
1138 struct roc_nix_rq *rq;
1144 mtr[0] = nix_mtr_find(dev, id);
1149 idx0 = roc_nix_bpf_level_to_idx(lvl_map[mtr[0]->level]);
1150 if (idx0 == ROC_NIX_BPF_LEVEL_IDX_INVALID)
1153 lvl_mask = ROC_NIX_BPF_LEVEL_F_LEAF;
1154 if (mtr[0]->is_used)
1155 per_lvl_cnt[idx0] = 0;
1157 per_lvl_cnt[idx0] = 1;
1159 if (mtr[0]->is_next) {
1160 mtr[1] = nix_mtr_find(dev, mtr[0]->next_id);
1164 idx1 = roc_nix_bpf_level_to_idx(lvl_map[mtr[1]->level]);
1165 if (idx1 == ROC_NIX_BPF_LEVEL_IDX_INVALID)
1168 lvl_mask |= ROC_NIX_BPF_LEVEL_F_MID;
1169 if (mtr[1]->is_used)
1170 per_lvl_cnt[idx1] = 0;
1172 per_lvl_cnt[idx1] = 1;
1175 if (mtr[1] && mtr[1]->is_next) {
1176 mtr[2] = nix_mtr_find(dev, mtr[1]->next_id);
1181 idx2 = roc_nix_bpf_level_to_idx(lvl_map[mtr[2]->level]);
1182 if (idx2 == ROC_NIX_BPF_LEVEL_IDX_INVALID)
1185 lvl_mask |= ROC_NIX_BPF_LEVEL_F_TOP;
1186 if (mtr[2]->is_used)
1187 per_lvl_cnt[idx2] = 0;
1189 per_lvl_cnt[idx2] = 1;
1192 rc = roc_nix_bpf_alloc(nix, lvl_mask, per_lvl_cnt, profs);
1195 if (mtr[0]->bpf_id == ROC_NIX_BPF_ID_INVALID)
1196 mtr[0]->bpf_id = profs[idx0].ids[0];
1199 if (mtr[0]->is_next && idx1 != ROC_NIX_BPF_LEVEL_IDX_INVALID)
1200 if (mtr[1]->bpf_id == ROC_NIX_BPF_ID_INVALID)
1201 mtr[1]->bpf_id = profs[idx1].ids[0];
1204 if (mtr[1]->is_next && idx2 != ROC_NIX_BPF_LEVEL_IDX_INVALID)
1205 if (mtr[2]->bpf_id == ROC_NIX_BPF_ID_INVALID)
1206 mtr[2]->bpf_id = profs[idx2].ids[0];
1208 for (i = 0; i < ROC_NIX_BPF_LEVEL_MAX; i++) {
1210 if (!mtr[i]->is_used) {
1211 memset(&cfg, 0, sizeof(struct roc_nix_bpf_cfg));
1212 nix_mtr_config_map(mtr[i], &cfg);
1213 rc = roc_nix_bpf_config(nix, mtr[i]->bpf_id,
1214 lvl_map[mtr[i]->level],
1218 sizeof(struct roc_nix_bpf_precolor));
1219 nix_dscp_table_map(mtr[i], &tbl);
1220 rc = roc_nix_bpf_pre_color_tbl_setup(nix,
1221 mtr[i]->bpf_id, lvl_map[mtr[i]->level],
1224 if (mtr[i]->params.meter_enable) {
1225 for (j = 0; j < mtr[i]->rq_num; j++) {
1226 rq = &dev->rqs[mtr[i]->rq_id
1228 rc = roc_nix_bpf_ena_dis(nix,
1241 nix_mtr_color_action_validate(struct rte_eth_dev *eth_dev, uint32_t id,
1242 uint32_t *prev_id, uint32_t *next_id,
1243 struct cnxk_mtr_policy_node *policy,
1246 uint32_t action_fate_red = policy->actions[RTE_COLOR_RED].action_fate;
1247 uint32_t action_fate_green =
1248 policy->actions[RTE_COLOR_GREEN].action_fate;
1249 uint32_t action_fate_yellow =
1250 policy->actions[RTE_COLOR_YELLOW].action_fate;
1251 uint32_t cur_mtr_id = *next_id;
1252 uint32_t next_mtr_id = 0xffff;
1253 uint32_t prev_mtr_id = 0xffff;
1254 struct cnxk_meter_node *mtr;
1256 if (action_fate_green == RTE_FLOW_ACTION_TYPE_METER)
1257 next_mtr_id = policy->actions[RTE_COLOR_GREEN].mtr_id;
1259 if (action_fate_yellow == RTE_FLOW_ACTION_TYPE_METER)
1260 next_mtr_id = policy->actions[RTE_COLOR_YELLOW].mtr_id;
1262 if (action_fate_red == RTE_FLOW_ACTION_TYPE_METER)
1263 next_mtr_id = policy->actions[RTE_COLOR_RED].mtr_id;
1265 if (next_mtr_id != 0xffff) {
1266 switch (*tree_level) {
1268 mtr = nix_get_mtr(eth_dev, cur_mtr_id);
1269 if (mtr->level == ROC_NIX_BPF_LEVEL_IDX_INVALID) {
1270 nix_mtr_level_update(eth_dev, cur_mtr_id, 0);
1271 nix_mtr_chain_update(eth_dev, cur_mtr_id, -1,
1274 if (mtr->level == 0)
1275 mtr->is_used = true;
1280 *next_id = next_mtr_id;
1283 mtr = nix_get_mtr(eth_dev, cur_mtr_id);
1284 if (mtr->level == ROC_NIX_BPF_LEVEL_IDX_INVALID) {
1285 nix_mtr_level_update(eth_dev, cur_mtr_id, 1);
1287 nix_mtr_chain_update(eth_dev, cur_mtr_id,
1288 prev_mtr_id, next_mtr_id);
1290 if (mtr->level == 1) {
1293 nix_mtr_chain_update(eth_dev,
1294 cur_mtr_id, prev_mtr_id,
1297 mtr->is_used = true;
1303 *next_id = next_mtr_id;
1304 *prev_id = cur_mtr_id;
1307 nix_mtr_chain_reset(eth_dev, id);
1311 switch (*tree_level) {
1313 mtr = nix_get_mtr(eth_dev, cur_mtr_id);
1314 if (mtr->level == ROC_NIX_BPF_LEVEL_IDX_INVALID) {
1315 nix_mtr_level_update(eth_dev, cur_mtr_id, 0);
1317 if (mtr->level == 0)
1318 mtr->is_used = true;
1324 mtr = nix_get_mtr(eth_dev, cur_mtr_id);
1325 if (mtr->level == ROC_NIX_BPF_LEVEL_IDX_INVALID) {
1326 nix_mtr_level_update(eth_dev, cur_mtr_id, 1);
1328 nix_mtr_chain_update(eth_dev, cur_mtr_id,
1331 if (mtr->level == 1) {
1334 nix_mtr_chain_update(eth_dev,
1337 mtr->is_used = true;
1344 mtr = nix_get_mtr(eth_dev, cur_mtr_id);
1345 if (mtr->level == ROC_NIX_BPF_LEVEL_IDX_INVALID) {
1346 nix_mtr_level_update(eth_dev, cur_mtr_id, 2);
1347 prev_mtr_id = *prev_id;
1348 nix_mtr_chain_update(eth_dev, cur_mtr_id,
1351 if (mtr->level == 2) {
1353 prev_mtr_id = *prev_id;
1354 nix_mtr_chain_update(eth_dev,
1357 mtr->is_used = true;
1371 nix_mtr_capabilities_init(struct rte_eth_dev *eth_dev)
1373 struct rte_mtr_capabilities capa;
1374 struct rte_mtr_error error;
1376 return cnxk_nix_mtr_capabilities_get(eth_dev, &capa, &error);