1
2
3
4#include <rte_tm_driver.h>
5
6#include "iavf.h"
7
8static int iavf_hierarchy_commit(struct rte_eth_dev *dev,
9 __rte_unused int clear_on_fail,
10 __rte_unused struct rte_tm_error *error);
11static int iavf_shaper_profile_add(struct rte_eth_dev *dev,
12 uint32_t shaper_profile_id,
13 struct rte_tm_shaper_params *profile,
14 struct rte_tm_error *error);
15static int iavf_shaper_profile_del(struct rte_eth_dev *dev,
16 uint32_t shaper_profile_id,
17 struct rte_tm_error *error);
18static int iavf_tm_node_add(struct rte_eth_dev *dev, uint32_t node_id,
19 uint32_t parent_node_id, uint32_t priority,
20 uint32_t weight, uint32_t level_id,
21 struct rte_tm_node_params *params,
22 struct rte_tm_error *error);
23static int iavf_tm_node_delete(struct rte_eth_dev *dev, uint32_t node_id,
24 struct rte_tm_error *error);
25static int iavf_tm_capabilities_get(struct rte_eth_dev *dev,
26 struct rte_tm_capabilities *cap,
27 struct rte_tm_error *error);
28static int iavf_level_capabilities_get(struct rte_eth_dev *dev,
29 uint32_t level_id,
30 struct rte_tm_level_capabilities *cap,
31 struct rte_tm_error *error);
32static int iavf_node_capabilities_get(struct rte_eth_dev *dev,
33 uint32_t node_id,
34 struct rte_tm_node_capabilities *cap,
35 struct rte_tm_error *error);
36static int iavf_node_type_get(struct rte_eth_dev *dev, uint32_t node_id,
37 int *is_leaf, struct rte_tm_error *error);
38
39const struct rte_tm_ops iavf_tm_ops = {
40 .shaper_profile_add = iavf_shaper_profile_add,
41 .shaper_profile_delete = iavf_shaper_profile_del,
42 .node_add = iavf_tm_node_add,
43 .node_delete = iavf_tm_node_delete,
44 .capabilities_get = iavf_tm_capabilities_get,
45 .level_capabilities_get = iavf_level_capabilities_get,
46 .node_capabilities_get = iavf_node_capabilities_get,
47 .node_type_get = iavf_node_type_get,
48 .hierarchy_commit = iavf_hierarchy_commit,
49};
50
51void
52iavf_tm_conf_init(struct rte_eth_dev *dev)
53{
54 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(dev->data->dev_private);
55
56
57 TAILQ_INIT(&vf->tm_conf.shaper_profile_list);
58
59
60 vf->tm_conf.root = NULL;
61 TAILQ_INIT(&vf->tm_conf.tc_list);
62 TAILQ_INIT(&vf->tm_conf.queue_list);
63 vf->tm_conf.nb_tc_node = 0;
64 vf->tm_conf.nb_queue_node = 0;
65 vf->tm_conf.committed = false;
66}
67
68void
69iavf_tm_conf_uninit(struct rte_eth_dev *dev)
70{
71 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(dev->data->dev_private);
72 struct iavf_tm_shaper_profile *shaper_profile;
73 struct iavf_tm_node *tm_node;
74
75
76 while ((tm_node = TAILQ_FIRST(&vf->tm_conf.queue_list))) {
77 TAILQ_REMOVE(&vf->tm_conf.queue_list, tm_node, node);
78 rte_free(tm_node);
79 }
80 vf->tm_conf.nb_queue_node = 0;
81 while ((tm_node = TAILQ_FIRST(&vf->tm_conf.tc_list))) {
82 TAILQ_REMOVE(&vf->tm_conf.tc_list, tm_node, node);
83 rte_free(tm_node);
84 }
85 vf->tm_conf.nb_tc_node = 0;
86 if (vf->tm_conf.root) {
87 rte_free(vf->tm_conf.root);
88 vf->tm_conf.root = NULL;
89 }
90
91
92 while ((shaper_profile =
93 TAILQ_FIRST(&vf->tm_conf.shaper_profile_list))) {
94 TAILQ_REMOVE(&vf->tm_conf.shaper_profile_list,
95 shaper_profile, node);
96 rte_free(shaper_profile);
97 }
98}
99
100static inline struct iavf_tm_node *
101iavf_tm_node_search(struct rte_eth_dev *dev,
102 uint32_t node_id, enum iavf_tm_node_type *node_type)
103{
104 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(dev->data->dev_private);
105 struct iavf_tm_node_list *tc_list = &vf->tm_conf.tc_list;
106 struct iavf_tm_node_list *queue_list = &vf->tm_conf.queue_list;
107 struct iavf_tm_node *tm_node;
108
109 if (vf->tm_conf.root && vf->tm_conf.root->id == node_id) {
110 *node_type = IAVF_TM_NODE_TYPE_PORT;
111 return vf->tm_conf.root;
112 }
113
114 TAILQ_FOREACH(tm_node, tc_list, node) {
115 if (tm_node->id == node_id) {
116 *node_type = IAVF_TM_NODE_TYPE_TC;
117 return tm_node;
118 }
119 }
120
121 TAILQ_FOREACH(tm_node, queue_list, node) {
122 if (tm_node->id == node_id) {
123 *node_type = IAVF_TM_NODE_TYPE_QUEUE;
124 return tm_node;
125 }
126 }
127
128 return NULL;
129}
130
131static int
132iavf_node_param_check(struct iavf_info *vf, uint32_t node_id,
133 uint32_t priority, uint32_t weight,
134 struct rte_tm_node_params *params,
135 struct rte_tm_error *error)
136{
137
138 if (node_id == RTE_TM_NODE_ID_NULL) {
139 error->type = RTE_TM_ERROR_TYPE_NODE_ID;
140 error->message = "invalid node id";
141 return -EINVAL;
142 }
143
144 if (priority) {
145 error->type = RTE_TM_ERROR_TYPE_NODE_PRIORITY;
146 error->message = "priority should be 0";
147 return -EINVAL;
148 }
149
150 if (weight != 1) {
151 error->type = RTE_TM_ERROR_TYPE_NODE_WEIGHT;
152 error->message = "weight must be 1";
153 return -EINVAL;
154 }
155
156
157 if (params->shared_shaper_id) {
158 error->type = RTE_TM_ERROR_TYPE_NODE_PARAMS_SHARED_SHAPER_ID;
159 error->message = "shared shaper not supported";
160 return -EINVAL;
161 }
162 if (params->n_shared_shapers) {
163 error->type = RTE_TM_ERROR_TYPE_NODE_PARAMS_N_SHARED_SHAPERS;
164 error->message = "shared shaper not supported";
165 return -EINVAL;
166 }
167
168
169 if (node_id >= vf->num_queue_pairs) {
170 if (params->nonleaf.wfq_weight_mode) {
171 error->type =
172 RTE_TM_ERROR_TYPE_NODE_PARAMS_WFQ_WEIGHT_MODE;
173 error->message = "WFQ not supported";
174 return -EINVAL;
175 }
176 if (params->nonleaf.n_sp_priorities != 1) {
177 error->type =
178 RTE_TM_ERROR_TYPE_NODE_PARAMS_N_SP_PRIORITIES;
179 error->message = "SP priority not supported";
180 return -EINVAL;
181 } else if (params->nonleaf.wfq_weight_mode &&
182 !(*params->nonleaf.wfq_weight_mode)) {
183 error->type =
184 RTE_TM_ERROR_TYPE_NODE_PARAMS_WFQ_WEIGHT_MODE;
185 error->message = "WFP should be byte mode";
186 return -EINVAL;
187 }
188
189 return 0;
190 }
191
192
193 if (params->leaf.cman) {
194 error->type = RTE_TM_ERROR_TYPE_NODE_PARAMS_CMAN;
195 error->message = "Congestion management not supported";
196 return -EINVAL;
197 }
198 if (params->leaf.wred.wred_profile_id !=
199 RTE_TM_WRED_PROFILE_ID_NONE) {
200 error->type =
201 RTE_TM_ERROR_TYPE_NODE_PARAMS_WRED_PROFILE_ID;
202 error->message = "WRED not supported";
203 return -EINVAL;
204 }
205 if (params->leaf.wred.shared_wred_context_id) {
206 error->type =
207 RTE_TM_ERROR_TYPE_NODE_PARAMS_SHARED_WRED_CONTEXT_ID;
208 error->message = "WRED not supported";
209 return -EINVAL;
210 }
211 if (params->leaf.wred.n_shared_wred_contexts) {
212 error->type =
213 RTE_TM_ERROR_TYPE_NODE_PARAMS_N_SHARED_WRED_CONTEXTS;
214 error->message = "WRED not supported";
215 return -EINVAL;
216 }
217
218 return 0;
219}
220
221static int
222iavf_node_type_get(struct rte_eth_dev *dev, uint32_t node_id,
223 int *is_leaf, struct rte_tm_error *error)
224{
225 enum iavf_tm_node_type node_type = IAVF_TM_NODE_TYPE_MAX;
226 struct iavf_tm_node *tm_node;
227
228 if (!is_leaf || !error)
229 return -EINVAL;
230
231 if (node_id == RTE_TM_NODE_ID_NULL) {
232 error->type = RTE_TM_ERROR_TYPE_NODE_ID;
233 error->message = "invalid node id";
234 return -EINVAL;
235 }
236
237
238 tm_node = iavf_tm_node_search(dev, node_id, &node_type);
239 if (!tm_node) {
240 error->type = RTE_TM_ERROR_TYPE_NODE_ID;
241 error->message = "no such node";
242 return -EINVAL;
243 }
244
245 if (node_type == IAVF_TM_NODE_TYPE_QUEUE)
246 *is_leaf = true;
247 else
248 *is_leaf = false;
249
250 return 0;
251}
252
253static inline struct iavf_tm_shaper_profile *
254iavf_shaper_profile_search(struct rte_eth_dev *dev,
255 uint32_t shaper_profile_id)
256{
257 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(dev->data->dev_private);
258 struct iavf_shaper_profile_list *shaper_profile_list =
259 &vf->tm_conf.shaper_profile_list;
260 struct iavf_tm_shaper_profile *shaper_profile;
261
262 TAILQ_FOREACH(shaper_profile, shaper_profile_list, node) {
263 if (shaper_profile_id == shaper_profile->shaper_profile_id)
264 return shaper_profile;
265 }
266
267 return NULL;
268}
269
270static int
271iavf_tm_node_add(struct rte_eth_dev *dev, uint32_t node_id,
272 uint32_t parent_node_id, uint32_t priority,
273 uint32_t weight, uint32_t level_id,
274 struct rte_tm_node_params *params,
275 struct rte_tm_error *error)
276{
277 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(dev->data->dev_private);
278 enum iavf_tm_node_type node_type = IAVF_TM_NODE_TYPE_MAX;
279 enum iavf_tm_node_type parent_node_type = IAVF_TM_NODE_TYPE_MAX;
280 struct iavf_tm_shaper_profile *shaper_profile = NULL;
281 struct iavf_tm_node *tm_node;
282 struct iavf_tm_node *parent_node;
283 uint16_t tc_nb = vf->qos_cap->num_elem;
284 int ret;
285
286 if (!params || !error)
287 return -EINVAL;
288
289
290 if (vf->tm_conf.committed) {
291 error->type = RTE_TM_ERROR_TYPE_UNSPECIFIED;
292 error->message = "already committed";
293 return -EINVAL;
294 }
295
296 ret = iavf_node_param_check(vf, node_id, priority, weight,
297 params, error);
298 if (ret)
299 return ret;
300
301
302 if (iavf_tm_node_search(dev, node_id, &node_type)) {
303 error->type = RTE_TM_ERROR_TYPE_NODE_ID;
304 error->message = "node id already used";
305 return -EINVAL;
306 }
307
308
309 if (params->shaper_profile_id != RTE_TM_SHAPER_PROFILE_ID_NONE) {
310 shaper_profile = iavf_shaper_profile_search(dev,
311 params->shaper_profile_id);
312 if (!shaper_profile) {
313 error->type =
314 RTE_TM_ERROR_TYPE_NODE_PARAMS_SHAPER_PROFILE_ID;
315 error->message = "shaper profile not exist";
316 return -EINVAL;
317 }
318 }
319
320
321 if (parent_node_id == RTE_TM_NODE_ID_NULL) {
322
323 if (level_id != IAVF_TM_NODE_TYPE_PORT) {
324 error->type = RTE_TM_ERROR_TYPE_NODE_PARAMS;
325 error->message = "Wrong level";
326 return -EINVAL;
327 }
328
329
330 if (vf->tm_conf.root) {
331 error->type = RTE_TM_ERROR_TYPE_NODE_PARENT_NODE_ID;
332 error->message = "already have a root";
333 return -EINVAL;
334 }
335
336
337 tm_node = rte_zmalloc("iavf_tm_node",
338 sizeof(struct iavf_tm_node),
339 0);
340 if (!tm_node)
341 return -ENOMEM;
342 tm_node->id = node_id;
343 tm_node->parent = NULL;
344 tm_node->reference_count = 0;
345 rte_memcpy(&tm_node->params, params,
346 sizeof(struct rte_tm_node_params));
347 vf->tm_conf.root = tm_node;
348 return 0;
349 }
350
351
352
353 parent_node = iavf_tm_node_search(dev, parent_node_id,
354 &parent_node_type);
355 if (!parent_node) {
356 error->type = RTE_TM_ERROR_TYPE_NODE_PARENT_NODE_ID;
357 error->message = "parent not exist";
358 return -EINVAL;
359 }
360 if (parent_node_type != IAVF_TM_NODE_TYPE_PORT &&
361 parent_node_type != IAVF_TM_NODE_TYPE_TC) {
362 error->type = RTE_TM_ERROR_TYPE_NODE_PARENT_NODE_ID;
363 error->message = "parent is not root or TC";
364 return -EINVAL;
365 }
366
367 if (level_id != RTE_TM_NODE_LEVEL_ID_ANY &&
368 level_id != (uint32_t)parent_node_type + 1) {
369 error->type = RTE_TM_ERROR_TYPE_NODE_PARAMS;
370 error->message = "Wrong level";
371 return -EINVAL;
372 }
373
374
375 if (parent_node_type == IAVF_TM_NODE_TYPE_PORT) {
376
377 if (vf->tm_conf.nb_tc_node >= tc_nb) {
378 error->type = RTE_TM_ERROR_TYPE_NODE_ID;
379 error->message = "too many TCs";
380 return -EINVAL;
381 }
382 } else {
383
384 if (parent_node->reference_count >= vf->num_queue_pairs) {
385 error->type = RTE_TM_ERROR_TYPE_NODE_ID;
386 error->message = "too many queues";
387 return -EINVAL;
388 }
389 if (node_id >= vf->num_queue_pairs) {
390 error->type = RTE_TM_ERROR_TYPE_NODE_ID;
391 error->message = "too large queue id";
392 return -EINVAL;
393 }
394 }
395
396
397 tm_node = rte_zmalloc("iavf_tm_node",
398 sizeof(struct iavf_tm_node),
399 0);
400 if (!tm_node)
401 return -ENOMEM;
402 tm_node->id = node_id;
403 tm_node->reference_count = 0;
404 tm_node->parent = parent_node;
405 tm_node->shaper_profile = shaper_profile;
406 rte_memcpy(&tm_node->params, params,
407 sizeof(struct rte_tm_node_params));
408 if (parent_node_type == IAVF_TM_NODE_TYPE_PORT) {
409 TAILQ_INSERT_TAIL(&vf->tm_conf.tc_list,
410 tm_node, node);
411 tm_node->tc = vf->tm_conf.nb_tc_node;
412 vf->tm_conf.nb_tc_node++;
413 } else {
414 TAILQ_INSERT_TAIL(&vf->tm_conf.queue_list,
415 tm_node, node);
416 tm_node->tc = parent_node->tc;
417 vf->tm_conf.nb_queue_node++;
418 }
419 tm_node->parent->reference_count++;
420
421
422 if (shaper_profile)
423 shaper_profile->reference_count++;
424
425 return 0;
426}
427
428static int
429iavf_tm_node_delete(struct rte_eth_dev *dev, uint32_t node_id,
430 struct rte_tm_error *error)
431{
432 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(dev->data->dev_private);
433 enum iavf_tm_node_type node_type = IAVF_TM_NODE_TYPE_MAX;
434 struct iavf_tm_node *tm_node;
435
436 if (!error)
437 return -EINVAL;
438
439
440 if (vf->tm_conf.committed) {
441 error->type = RTE_TM_ERROR_TYPE_UNSPECIFIED;
442 error->message = "already committed";
443 return -EINVAL;
444 }
445
446 if (node_id == RTE_TM_NODE_ID_NULL) {
447 error->type = RTE_TM_ERROR_TYPE_NODE_ID;
448 error->message = "invalid node id";
449 return -EINVAL;
450 }
451
452
453 tm_node = iavf_tm_node_search(dev, node_id, &node_type);
454 if (!tm_node) {
455 error->type = RTE_TM_ERROR_TYPE_NODE_ID;
456 error->message = "no such node";
457 return -EINVAL;
458 }
459
460
461 if (tm_node->reference_count) {
462 error->type = RTE_TM_ERROR_TYPE_NODE_ID;
463 error->message =
464 "cannot delete a node which has children";
465 return -EINVAL;
466 }
467
468
469 if (node_type == IAVF_TM_NODE_TYPE_PORT) {
470 rte_free(tm_node);
471 vf->tm_conf.root = NULL;
472 return 0;
473 }
474
475
476 tm_node->parent->reference_count--;
477 if (node_type == IAVF_TM_NODE_TYPE_TC) {
478 TAILQ_REMOVE(&vf->tm_conf.tc_list, tm_node, node);
479 vf->tm_conf.nb_tc_node--;
480 } else {
481 TAILQ_REMOVE(&vf->tm_conf.queue_list, tm_node, node);
482 vf->tm_conf.nb_queue_node--;
483 }
484 rte_free(tm_node);
485
486 return 0;
487}
488
489static int
490iavf_shaper_profile_param_check(struct rte_tm_shaper_params *profile,
491 struct rte_tm_error *error)
492{
493
494 if (profile->committed.size) {
495 error->type = RTE_TM_ERROR_TYPE_SHAPER_PROFILE_COMMITTED_SIZE;
496 error->message = "committed bucket size not supported";
497 return -EINVAL;
498 }
499
500 if (profile->peak.size) {
501 error->type = RTE_TM_ERROR_TYPE_SHAPER_PROFILE_PEAK_SIZE;
502 error->message = "peak bucket size not supported";
503 return -EINVAL;
504 }
505
506 if (profile->pkt_length_adjust) {
507 error->type = RTE_TM_ERROR_TYPE_SHAPER_PROFILE_PKT_ADJUST_LEN;
508 error->message = "packet length adjustment not supported";
509 return -EINVAL;
510 }
511
512 return 0;
513}
514
515static int
516iavf_shaper_profile_add(struct rte_eth_dev *dev,
517 uint32_t shaper_profile_id,
518 struct rte_tm_shaper_params *profile,
519 struct rte_tm_error *error)
520{
521 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(dev->data->dev_private);
522 struct iavf_tm_shaper_profile *shaper_profile;
523 int ret;
524
525 if (!profile || !error)
526 return -EINVAL;
527
528 ret = iavf_shaper_profile_param_check(profile, error);
529 if (ret)
530 return ret;
531
532 shaper_profile = iavf_shaper_profile_search(dev, shaper_profile_id);
533
534 if (shaper_profile) {
535 error->type = RTE_TM_ERROR_TYPE_SHAPER_PROFILE_ID;
536 error->message = "profile ID exist";
537 return -EINVAL;
538 }
539
540 shaper_profile = rte_zmalloc("iavf_tm_shaper_profile",
541 sizeof(struct iavf_tm_shaper_profile),
542 0);
543 if (!shaper_profile)
544 return -ENOMEM;
545 shaper_profile->shaper_profile_id = shaper_profile_id;
546 rte_memcpy(&shaper_profile->profile, profile,
547 sizeof(struct rte_tm_shaper_params));
548 TAILQ_INSERT_TAIL(&vf->tm_conf.shaper_profile_list,
549 shaper_profile, node);
550
551 return 0;
552}
553
554static int
555iavf_shaper_profile_del(struct rte_eth_dev *dev,
556 uint32_t shaper_profile_id,
557 struct rte_tm_error *error)
558{
559 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(dev->data->dev_private);
560 struct iavf_tm_shaper_profile *shaper_profile;
561
562 if (!error)
563 return -EINVAL;
564
565 shaper_profile = iavf_shaper_profile_search(dev, shaper_profile_id);
566
567 if (!shaper_profile) {
568 error->type = RTE_TM_ERROR_TYPE_SHAPER_PROFILE_ID;
569 error->message = "profile ID not exist";
570 return -EINVAL;
571 }
572
573
574 if (shaper_profile->reference_count) {
575 error->type = RTE_TM_ERROR_TYPE_SHAPER_PROFILE;
576 error->message = "profile in use";
577 return -EINVAL;
578 }
579
580 TAILQ_REMOVE(&vf->tm_conf.shaper_profile_list, shaper_profile, node);
581 rte_free(shaper_profile);
582
583 return 0;
584}
585
586static int
587iavf_tm_capabilities_get(struct rte_eth_dev *dev,
588 struct rte_tm_capabilities *cap,
589 struct rte_tm_error *error)
590{
591 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(dev->data->dev_private);
592 uint16_t tc_nb = vf->qos_cap->num_elem;
593
594 if (!cap || !error)
595 return -EINVAL;
596
597 if (tc_nb > vf->vf_res->num_queue_pairs)
598 return -EINVAL;
599
600 error->type = RTE_TM_ERROR_TYPE_NONE;
601
602
603 memset(cap, 0, sizeof(struct rte_tm_capabilities));
604
605
606
607
608
609 cap->n_nodes_max = 1 + IAVF_MAX_TRAFFIC_CLASS
610 + vf->num_queue_pairs;
611 cap->n_levels_max = 3;
612 cap->non_leaf_nodes_identical = 1;
613 cap->leaf_nodes_identical = 1;
614 cap->shaper_n_max = cap->n_nodes_max;
615 cap->shaper_private_n_max = cap->n_nodes_max;
616 cap->shaper_private_dual_rate_n_max = 0;
617 cap->shaper_private_rate_min = 0;
618
619 cap->shaper_private_rate_max =
620 (uint64_t)vf->link_speed * 1000000 / IAVF_BITS_PER_BYTE;
621 cap->shaper_private_packet_mode_supported = 0;
622 cap->shaper_private_byte_mode_supported = 1;
623 cap->shaper_shared_n_max = 0;
624 cap->shaper_shared_n_nodes_per_shaper_max = 0;
625 cap->shaper_shared_n_shapers_per_node_max = 0;
626 cap->shaper_shared_dual_rate_n_max = 0;
627 cap->shaper_shared_rate_min = 0;
628 cap->shaper_shared_rate_max = 0;
629 cap->shaper_shared_packet_mode_supported = 0;
630 cap->shaper_shared_byte_mode_supported = 0;
631 cap->sched_n_children_max = vf->num_queue_pairs;
632 cap->sched_sp_n_priorities_max = 1;
633 cap->sched_wfq_n_children_per_group_max = 0;
634 cap->sched_wfq_n_groups_max = 0;
635 cap->sched_wfq_weight_max = 1;
636 cap->sched_wfq_packet_mode_supported = 0;
637 cap->sched_wfq_byte_mode_supported = 0;
638 cap->cman_head_drop_supported = 0;
639 cap->dynamic_update_mask = 0;
640 cap->shaper_pkt_length_adjust_min = RTE_TM_ETH_FRAMING_OVERHEAD;
641 cap->shaper_pkt_length_adjust_max = RTE_TM_ETH_FRAMING_OVERHEAD_FCS;
642 cap->cman_wred_context_n_max = 0;
643 cap->cman_wred_context_private_n_max = 0;
644 cap->cman_wred_context_shared_n_max = 0;
645 cap->cman_wred_context_shared_n_nodes_per_context_max = 0;
646 cap->cman_wred_context_shared_n_contexts_per_node_max = 0;
647 cap->stats_mask = 0;
648
649 return 0;
650}
651
652static int
653iavf_level_capabilities_get(struct rte_eth_dev *dev,
654 uint32_t level_id,
655 struct rte_tm_level_capabilities *cap,
656 struct rte_tm_error *error)
657{
658 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(dev->data->dev_private);
659
660 if (!cap || !error)
661 return -EINVAL;
662
663 if (level_id >= IAVF_TM_NODE_TYPE_MAX) {
664 error->type = RTE_TM_ERROR_TYPE_LEVEL_ID;
665 error->message = "too deep level";
666 return -EINVAL;
667 }
668
669
670 if (level_id == IAVF_TM_NODE_TYPE_PORT) {
671 cap->n_nodes_max = 1;
672 cap->n_nodes_nonleaf_max = 1;
673 cap->n_nodes_leaf_max = 0;
674 } else if (level_id == IAVF_TM_NODE_TYPE_TC) {
675
676 cap->n_nodes_max = IAVF_MAX_TRAFFIC_CLASS;
677 cap->n_nodes_nonleaf_max = IAVF_MAX_TRAFFIC_CLASS;
678 cap->n_nodes_leaf_max = 0;
679 } else {
680
681 cap->n_nodes_max = vf->num_queue_pairs;
682 cap->n_nodes_nonleaf_max = 0;
683 cap->n_nodes_leaf_max = vf->num_queue_pairs;
684 }
685
686 cap->non_leaf_nodes_identical = true;
687 cap->leaf_nodes_identical = true;
688
689 if (level_id != IAVF_TM_NODE_TYPE_QUEUE) {
690 cap->nonleaf.shaper_private_supported = true;
691 cap->nonleaf.shaper_private_dual_rate_supported = false;
692 cap->nonleaf.shaper_private_rate_min = 0;
693
694 cap->nonleaf.shaper_private_rate_max =
695 (uint64_t)vf->link_speed * 1000000 / IAVF_BITS_PER_BYTE;
696 cap->nonleaf.shaper_private_packet_mode_supported = 0;
697 cap->nonleaf.shaper_private_byte_mode_supported = 1;
698 cap->nonleaf.shaper_shared_n_max = 0;
699 cap->nonleaf.shaper_shared_packet_mode_supported = 0;
700 cap->nonleaf.shaper_shared_byte_mode_supported = 0;
701 if (level_id == IAVF_TM_NODE_TYPE_PORT)
702 cap->nonleaf.sched_n_children_max =
703 IAVF_MAX_TRAFFIC_CLASS;
704 else
705 cap->nonleaf.sched_n_children_max =
706 vf->num_queue_pairs;
707 cap->nonleaf.sched_sp_n_priorities_max = 1;
708 cap->nonleaf.sched_wfq_n_children_per_group_max = 0;
709 cap->nonleaf.sched_wfq_n_groups_max = 0;
710 cap->nonleaf.sched_wfq_weight_max = 1;
711 cap->nonleaf.sched_wfq_packet_mode_supported = 0;
712 cap->nonleaf.sched_wfq_byte_mode_supported = 0;
713 cap->nonleaf.stats_mask = 0;
714
715 return 0;
716 }
717
718
719 cap->leaf.shaper_private_supported = false;
720 cap->leaf.shaper_private_dual_rate_supported = false;
721 cap->leaf.shaper_private_rate_min = 0;
722
723 cap->leaf.shaper_private_rate_max =
724 (uint64_t)vf->link_speed * 1000000 / IAVF_BITS_PER_BYTE;
725 cap->leaf.shaper_private_packet_mode_supported = 0;
726 cap->leaf.shaper_private_byte_mode_supported = 1;
727 cap->leaf.shaper_shared_n_max = 0;
728 cap->leaf.shaper_shared_packet_mode_supported = 0;
729 cap->leaf.shaper_shared_byte_mode_supported = 0;
730 cap->leaf.cman_head_drop_supported = false;
731 cap->leaf.cman_wred_context_private_supported = true;
732 cap->leaf.cman_wred_context_shared_n_max = 0;
733 cap->leaf.stats_mask = 0;
734
735 return 0;
736}
737
738static int
739iavf_node_capabilities_get(struct rte_eth_dev *dev,
740 uint32_t node_id,
741 struct rte_tm_node_capabilities *cap,
742 struct rte_tm_error *error)
743{
744 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(dev->data->dev_private);
745 enum iavf_tm_node_type node_type;
746 struct virtchnl_qos_cap_elem tc_cap;
747 struct iavf_tm_node *tm_node;
748
749 if (!cap || !error)
750 return -EINVAL;
751
752 if (node_id == RTE_TM_NODE_ID_NULL) {
753 error->type = RTE_TM_ERROR_TYPE_NODE_ID;
754 error->message = "invalid node id";
755 return -EINVAL;
756 }
757
758
759 tm_node = iavf_tm_node_search(dev, node_id, &node_type);
760 if (!tm_node) {
761 error->type = RTE_TM_ERROR_TYPE_NODE_ID;
762 error->message = "no such node";
763 return -EINVAL;
764 }
765
766 if (node_type != IAVF_TM_NODE_TYPE_TC) {
767 error->type = RTE_TM_ERROR_TYPE_NODE_PARAMS;
768 error->message = "not support capability get";
769 return -EINVAL;
770 }
771
772 tc_cap = vf->qos_cap->cap[tm_node->tc];
773 if (tc_cap.tc_num != tm_node->tc) {
774 error->type = RTE_TM_ERROR_TYPE_NODE_PARAMS;
775 error->message = "tc not match";
776 return -EINVAL;
777 }
778
779 cap->shaper_private_supported = true;
780 cap->shaper_private_dual_rate_supported = false;
781
782 cap->shaper_private_rate_min =
783 (uint64_t)tc_cap.shaper.committed * 1000 / IAVF_BITS_PER_BYTE;
784 cap->shaper_private_rate_max =
785 (uint64_t)tc_cap.shaper.peak * 1000 / IAVF_BITS_PER_BYTE;
786 cap->shaper_shared_n_max = 0;
787 cap->nonleaf.sched_n_children_max = vf->num_queue_pairs;
788 cap->nonleaf.sched_sp_n_priorities_max = 1;
789 cap->nonleaf.sched_wfq_n_children_per_group_max = 1;
790 cap->nonleaf.sched_wfq_n_groups_max = 0;
791 cap->nonleaf.sched_wfq_weight_max = tc_cap.weight;
792 cap->stats_mask = 0;
793
794 return 0;
795}
796
797static int iavf_hierarchy_commit(struct rte_eth_dev *dev,
798 int clear_on_fail,
799 __rte_unused struct rte_tm_error *error)
800{
801 struct iavf_info *vf = IAVF_DEV_PRIVATE_TO_VF(dev->data->dev_private);
802 struct iavf_adapter *adapter =
803 IAVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
804 struct virtchnl_queue_tc_mapping *q_tc_mapping;
805 struct virtchnl_queues_bw_cfg *q_bw;
806 struct iavf_tm_node_list *queue_list = &vf->tm_conf.queue_list;
807 struct iavf_tm_node *tm_node;
808 struct iavf_qtc_map *qtc_map;
809 uint16_t size, size_q;
810 int index = 0, node_committed = 0;
811 int i, ret_val = IAVF_SUCCESS;
812
813
814 if (adapter->stopped != 1) {
815 PMD_DRV_LOG(ERR, "Please stop port first");
816 ret_val = IAVF_ERR_NOT_READY;
817 goto err;
818 }
819
820 if (!(vf->vf_res->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_QOS)) {
821 PMD_DRV_LOG(ERR, "VF queue tc mapping is not supported");
822 ret_val = IAVF_NOT_SUPPORTED;
823 goto fail_clear;
824 }
825
826
827 if (vf->tm_conf.nb_tc_node != vf->qos_cap->num_elem) {
828 PMD_DRV_LOG(ERR, "Does not set VF vsi nodes to all TCs");
829 ret_val = IAVF_ERR_PARAM;
830 goto fail_clear;
831 }
832
833 size = sizeof(*q_tc_mapping) + sizeof(q_tc_mapping->tc[0]) *
834 (vf->qos_cap->num_elem - 1);
835 q_tc_mapping = rte_zmalloc("q_tc", size, 0);
836 if (!q_tc_mapping) {
837 ret_val = IAVF_ERR_NO_MEMORY;
838 goto fail_clear;
839 }
840
841 size_q = sizeof(*q_bw) + sizeof(q_bw->cfg[0]) *
842 (vf->num_queue_pairs - 1);
843 q_bw = rte_zmalloc("q_bw", size_q, 0);
844 if (!q_bw) {
845 ret_val = IAVF_ERR_NO_MEMORY;
846 goto fail_clear;
847 }
848
849 q_tc_mapping->vsi_id = vf->vsi.vsi_id;
850 q_tc_mapping->num_tc = vf->qos_cap->num_elem;
851 q_tc_mapping->num_queue_pairs = vf->num_queue_pairs;
852
853 q_bw->vsi_id = vf->vsi.vsi_id;
854 q_bw->num_queues = vf->num_queue_pairs;
855
856 TAILQ_FOREACH(tm_node, queue_list, node) {
857 if (tm_node->tc >= q_tc_mapping->num_tc) {
858 PMD_DRV_LOG(ERR, "TC%d is not enabled", tm_node->tc);
859 ret_val = IAVF_ERR_PARAM;
860 goto fail_clear;
861 }
862 q_tc_mapping->tc[tm_node->tc].req.queue_count++;
863
864 if (tm_node->shaper_profile) {
865 q_bw->cfg[node_committed].queue_id = node_committed;
866 q_bw->cfg[node_committed].shaper.peak =
867 tm_node->shaper_profile->profile.peak.rate /
868 1000 * IAVF_BITS_PER_BYTE;
869 q_bw->cfg[node_committed].shaper.committed =
870 tm_node->shaper_profile->profile.committed.rate /
871 1000 * IAVF_BITS_PER_BYTE;
872 q_bw->cfg[node_committed].tc = tm_node->tc;
873 }
874
875 node_committed++;
876 }
877
878
879 if (node_committed < vf->num_queue_pairs) {
880 PMD_DRV_LOG(ERR, "queue node is less than allocated queue pairs");
881 ret_val = IAVF_ERR_PARAM;
882 goto fail_clear;
883 }
884
885 ret_val = iavf_set_q_bw(dev, q_bw, size_q);
886 if (ret_val)
887 goto fail_clear;
888
889
890 qtc_map = rte_zmalloc("qtc_map",
891 sizeof(struct iavf_qtc_map) * q_tc_mapping->num_tc, 0);
892 if (!qtc_map)
893 return IAVF_ERR_NO_MEMORY;
894
895 for (i = 0; i < q_tc_mapping->num_tc; i++) {
896 q_tc_mapping->tc[i].req.start_queue_id = index;
897 index += q_tc_mapping->tc[i].req.queue_count;
898 qtc_map[i].tc = i;
899 qtc_map[i].start_queue_id =
900 q_tc_mapping->tc[i].req.start_queue_id;
901 qtc_map[i].queue_count = q_tc_mapping->tc[i].req.queue_count;
902 }
903
904 ret_val = iavf_set_q_tc_map(dev, q_tc_mapping, size);
905 if (ret_val)
906 goto fail_clear;
907
908 vf->qtc_map = qtc_map;
909 vf->tm_conf.committed = true;
910 return ret_val;
911
912fail_clear:
913
914 if (clear_on_fail) {
915 iavf_tm_conf_uninit(dev);
916 iavf_tm_conf_init(dev);
917 }
918err:
919 return ret_val;
920}
921
