drivers/net/ipn3ke/ipn3ke_tm.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2019 Intel Corporation
   3  */
   4
   5 #include <stdint.h>
   6 #include <stdlib.h>
   7 #include <string.h>
   8
   9 #include <rte_bus_pci.h>
  10 #include <rte_ethdev.h>
  11 #include <rte_pci.h>
  12 #include <rte_malloc.h>
  13 #include <rte_tm_driver.h>
  14
  15 #include <rte_mbuf.h>
  16 #include <rte_sched.h>
  17 #include <rte_ethdev_driver.h>
  18
  19 #include <rte_io.h>
  20 #include <rte_rawdev.h>
  21 #include <rte_rawdev_pmd.h>
  22 #include <rte_bus_ifpga.h>
  23 #include <ifpga_logs.h>
  24
  25 #include "ipn3ke_rawdev_api.h"
  26 #include "ipn3ke_flow.h"
  27 #include "ipn3ke_logs.h"
  28 #include "ipn3ke_ethdev.h"
  29
  30 #define BYTES_IN_MBPS     (1000 * 1000 / 8)
  31 #define SUBPORT_TC_PERIOD 10
  32 #define PIPE_TC_PERIOD    40
  33
  34 struct ipn3ke_tm_shaper_params_range_type {
  35         uint32_t m1;
  36         uint32_t m2;
  37         uint32_t exp;
  38         uint32_t exp2;
  39         uint32_t low;
  40         uint32_t high;
  41 };
  42 struct ipn3ke_tm_shaper_params_range_type ipn3ke_tm_shaper_params_rang[] = {
  43         {  0,       1,     0,        1,           0,            4},
  44         {  2,       3,     0,        1,           8,           12},
  45         {  4,       7,     0,        1,          16,           28},
  46         {  8,      15,     0,        1,          32,           60},
  47         { 16,      31,     0,        1,          64,          124},
  48         { 32,      63,     0,        1,         128,          252},
  49         { 64,     127,     0,        1,         256,          508},
  50         {128,     255,     0,        1,         512,         1020},
  51         {256,     511,     0,        1,        1024,         2044},
  52         {512,    1023,     0,        1,        2048,         4092},
  53         {512,    1023,     1,        2,        4096,         8184},
  54         {512,    1023,     2,        4,        8192,        16368},
  55         {512,    1023,     3,        8,       16384,        32736},
  56         {512,    1023,     4,       16,       32768,        65472},
  57         {512,    1023,     5,       32,       65536,       130944},
  58         {512,    1023,     6,       64,      131072,       261888},
  59         {512,    1023,     7,      128,      262144,       523776},
  60         {512,    1023,     8,      256,      524288,      1047552},
  61         {512,    1023,     9,      512,     1048576,      2095104},
  62         {512,    1023,    10,     1024,     2097152,      4190208},
  63         {512,    1023,    11,     2048,     4194304,      8380416},
  64         {512,    1023,    12,     4096,     8388608,     16760832},
  65         {512,    1023,    13,     8192,    16777216,     33521664},
  66         {512,    1023,    14,    16384,    33554432,     67043328},
  67         {512,    1023,    15,    32768,    67108864,    134086656},
  68 };
  69
  70 #define IPN3KE_TM_SHAPER_RANGE_NUM (sizeof(ipn3ke_tm_shaper_params_rang) / \
  71         sizeof(struct ipn3ke_tm_shaper_params_range_type))
  72
  73 #define IPN3KE_TM_SHAPER_COMMITTED_RATE_MAX \
  74         (ipn3ke_tm_shaper_params_rang[IPN3KE_TM_SHAPER_RANGE_NUM - 1].high)
  75
  76 #define IPN3KE_TM_SHAPER_PEAK_RATE_MAX \
  77         (ipn3ke_tm_shaper_params_rang[IPN3KE_TM_SHAPER_RANGE_NUM - 1].high)
  78
  79 int
  80 ipn3ke_hw_tm_init(struct ipn3ke_hw *hw)
  81 {
  82 #define SCRATCH_DATA 0xABCDEF
  83         struct ipn3ke_tm_node *nodes;
  84         struct ipn3ke_tm_tdrop_profile *tdrop_profile;
  85         int node_num;
  86         int i;
  87
  88         if (hw == NULL)
  89                 return -EINVAL;
  90 #if IPN3KE_TM_SCRATCH_RW
  91         uint32_t scratch_data;
  92         IPN3KE_MASK_WRITE_REG(hw,
  93                                         IPN3KE_TM_SCRATCH,
  94                                         0,
  95                                         SCRATCH_DATA,
  96                                         0xFFFFFFFF);
  97         scratch_data = IPN3KE_MASK_READ_REG(hw,
  98                                         IPN3KE_TM_SCRATCH,
  99                                         0,
 100                                         0xFFFFFFFF);
 101         if (scratch_data != SCRATCH_DATA)
 102                 return -EINVAL;
 103 #endif
 104         /* alloc memory for all hierarchy nodes */
 105         node_num = hw->port_num +
 106                 IPN3KE_TM_VT_NODE_NUM +
 107                 IPN3KE_TM_COS_NODE_NUM;
 108
 109         nodes = rte_zmalloc("ipn3ke_tm_nodes",
 110                         sizeof(struct ipn3ke_tm_node) * node_num,
 111                         0);
 112         if (!nodes)
 113                 return -ENOMEM;
 114
 115         /* alloc memory for Tail Drop Profile */
 116         tdrop_profile = rte_zmalloc("ipn3ke_tm_tdrop_profile",
 117                                 sizeof(struct ipn3ke_tm_tdrop_profile) *
 118                                 IPN3KE_TM_TDROP_PROFILE_NUM,
 119                                 0);
 120         if (!tdrop_profile) {
 121                 rte_free(nodes);
 122                 return -ENOMEM;
 123         }
 124
 125         hw->nodes = nodes;
 126         hw->port_nodes = nodes;
 127         hw->vt_nodes = hw->port_nodes + hw->port_num;
 128         hw->cos_nodes = hw->vt_nodes + IPN3KE_TM_VT_NODE_NUM;
 129         hw->tdrop_profile = tdrop_profile;
 130         hw->tdrop_profile_num = IPN3KE_TM_TDROP_PROFILE_NUM;
 131
 132         for (i = 0, nodes = hw->port_nodes;
 133                 i < hw->port_num;
 134                 i++, nodes++) {
 135                 nodes->node_index = i;
 136                 nodes->level = IPN3KE_TM_NODE_LEVEL_PORT;
 137                 nodes->tm_id = RTE_TM_NODE_ID_NULL;
 138                 nodes->node_state = IPN3KE_TM_NODE_STATE_IDLE;
 139                 nodes->parent_node_id = RTE_TM_NODE_ID_NULL;
 140                 nodes->priority = IPN3KE_TM_NODE_PRIORITY_NORMAL0;
 141                 nodes->weight = 0;
 142                 nodes->parent_node = NULL;
 143                 nodes->shaper_profile.valid = 0;
 144                 nodes->tdrop_profile = NULL;
 145                 nodes->n_children = 0;
 146                 TAILQ_INIT(&nodes->children_node_list);
 147         }
 148
 149         for (i = 0, nodes = hw->vt_nodes;
 150                 i < IPN3KE_TM_VT_NODE_NUM;
 151                 i++, nodes++) {
 152                 nodes->node_index = i;
 153                 nodes->level = IPN3KE_TM_NODE_LEVEL_VT;
 154                 nodes->tm_id = RTE_TM_NODE_ID_NULL;
 155                 nodes->node_state = IPN3KE_TM_NODE_STATE_IDLE;
 156                 nodes->parent_node_id = RTE_TM_NODE_ID_NULL;
 157                 nodes->priority = IPN3KE_TM_NODE_PRIORITY_NORMAL0;
 158                 nodes->weight = 0;
 159                 nodes->parent_node = NULL;
 160                 nodes->shaper_profile.valid = 0;
 161                 nodes->tdrop_profile = NULL;
 162                 nodes->n_children = 0;
 163                 TAILQ_INIT(&nodes->children_node_list);
 164         }
 165
 166         for (i = 0, nodes = hw->cos_nodes;
 167                 i < IPN3KE_TM_COS_NODE_NUM;
 168                 i++, nodes++) {
 169                 nodes->node_index = i;
 170                 nodes->level = IPN3KE_TM_NODE_LEVEL_COS;
 171                 nodes->tm_id = RTE_TM_NODE_ID_NULL;
 172                 nodes->node_state = IPN3KE_TM_NODE_STATE_IDLE;
 173                 nodes->parent_node_id = RTE_TM_NODE_ID_NULL;
 174                 nodes->priority = IPN3KE_TM_NODE_PRIORITY_NORMAL0;
 175                 nodes->weight = 0;
 176                 nodes->parent_node = NULL;
 177                 nodes->shaper_profile.valid = 0;
 178                 nodes->tdrop_profile = NULL;
 179                 nodes->n_children = 0;
 180                 TAILQ_INIT(&nodes->children_node_list);
 181         }
 182
 183         for (i = 0, tdrop_profile = hw->tdrop_profile;
 184                 i < IPN3KE_TM_TDROP_PROFILE_NUM;
 185                 i++, tdrop_profile++) {
 186                 tdrop_profile->tdrop_profile_id = i;
 187                 tdrop_profile->n_users = 0;
 188                 tdrop_profile->valid = 0;
 189         }
 190
 191         return 0;
 192 }
 193
 194 void
 195 ipn3ke_tm_init(struct ipn3ke_rpst *rpst)
 196 {
 197         struct ipn3ke_tm_internals *tm;
 198         struct ipn3ke_tm_node *port_node;
 199
 200         tm = &rpst->tm;
 201
 202         port_node = &rpst->hw->port_nodes[rpst->port_id];
 203         tm->h.port_node = port_node;
 204
 205         tm->h.n_shaper_profiles = 0;
 206         tm->h.n_tdrop_profiles = 0;
 207         tm->h.n_vt_nodes = 0;
 208         tm->h.n_cos_nodes = 0;
 209
 210         tm->h.port_commit_node = NULL;
 211         TAILQ_INIT(&tm->h.vt_commit_node_list);
 212         TAILQ_INIT(&tm->h.cos_commit_node_list);
 213
 214         tm->hierarchy_frozen = 0;
 215         tm->tm_started = 1;
 216         tm->tm_id = rpst->port_id;
 217 }
 218
 219 static struct ipn3ke_tm_shaper_profile *
 220 ipn3ke_hw_tm_shaper_profile_search(struct ipn3ke_hw *hw,
 221         uint32_t shaper_profile_id, struct rte_tm_error *error)
 222 {
 223         struct ipn3ke_tm_shaper_profile *sp = NULL;
 224         uint32_t level_of_node_id;
 225         uint32_t node_index;
 226
 227         /* Shaper profile ID must not be NONE. */
 228         if (shaper_profile_id == RTE_TM_SHAPER_PROFILE_ID_NONE) {
 229                 rte_tm_error_set(error,
 230                                 EINVAL,
 231                                 RTE_TM_ERROR_TYPE_SHAPER_PROFILE_ID,
 232                                 NULL,
 233                                 rte_strerror(EINVAL));
 234
 235                 return NULL;
 236         }
 237
 238         level_of_node_id = shaper_profile_id / IPN3KE_TM_NODE_LEVEL_MOD;
 239         node_index = shaper_profile_id % IPN3KE_TM_NODE_LEVEL_MOD;
 240
 241         switch (level_of_node_id) {
 242         case IPN3KE_TM_NODE_LEVEL_PORT:
 243                 if (node_index >= hw->port_num)
 244                         rte_tm_error_set(error,
 245                                         EEXIST,
 246                                         RTE_TM_ERROR_TYPE_SHAPER_PROFILE_ID,
 247                                         NULL,
 248                                         rte_strerror(EEXIST));
 249                 else
 250                         sp = &hw->port_nodes[node_index].shaper_profile;
 251
 252                 break;
 253
 254         case IPN3KE_TM_NODE_LEVEL_VT:
 255                 if (node_index >= IPN3KE_TM_VT_NODE_NUM)
 256                         rte_tm_error_set(error,
 257                                         EEXIST,
 258                                         RTE_TM_ERROR_TYPE_SHAPER_PROFILE_ID,
 259                                         NULL,
 260                                         rte_strerror(EEXIST));
 261                 else
 262                         sp = &hw->vt_nodes[node_index].shaper_profile;
 263
 264                 break;
 265
 266         case IPN3KE_TM_NODE_LEVEL_COS:
 267                 if (node_index >= IPN3KE_TM_COS_NODE_NUM)
 268                         rte_tm_error_set(error,
 269                                         EEXIST,
 270                                         RTE_TM_ERROR_TYPE_SHAPER_PROFILE_ID,
 271                                         NULL,
 272                                         rte_strerror(EEXIST));
 273                 else
 274                         sp = &hw->cos_nodes[node_index].shaper_profile;
 275
 276                 break;
 277         default:
 278                 rte_tm_error_set(error,
 279                                 EEXIST,
 280                                 RTE_TM_ERROR_TYPE_SHAPER_PROFILE_ID,
 281                                 NULL,
 282                                 rte_strerror(EEXIST));
 283         }
 284
 285         return sp;
 286 }
 287
 288 static struct ipn3ke_tm_tdrop_profile *
 289 ipn3ke_hw_tm_tdrop_profile_search(struct ipn3ke_hw *hw,
 290         uint32_t tdrop_profile_id)
 291 {
 292         struct ipn3ke_tm_tdrop_profile *tdrop_profile;
 293
 294         if (tdrop_profile_id >= hw->tdrop_profile_num)
 295                 return NULL;
 296
 297         tdrop_profile = &hw->tdrop_profile[tdrop_profile_id];
 298         if (tdrop_profile->valid)
 299                 return tdrop_profile;
 300
 301         return NULL;
 302 }
 303
 304 static struct ipn3ke_tm_node *
 305 ipn3ke_hw_tm_node_search(struct ipn3ke_hw *hw, uint32_t tm_id,
 306         uint32_t node_id, uint32_t state_mask)
 307 {
 308         uint32_t level_of_node_id;
 309         uint32_t node_index;
 310         struct ipn3ke_tm_node *n;
 311
 312         level_of_node_id = node_id / IPN3KE_TM_NODE_LEVEL_MOD;
 313         node_index = node_id % IPN3KE_TM_NODE_LEVEL_MOD;
 314
 315         switch (level_of_node_id) {
 316         case IPN3KE_TM_NODE_LEVEL_PORT:
 317                 if (node_index >= hw->port_num)
 318                         return NULL;
 319                 n = &hw->port_nodes[node_index];
 320
 321                 break;
 322         case IPN3KE_TM_NODE_LEVEL_VT:
 323                 if (node_index >= IPN3KE_TM_VT_NODE_NUM)
 324                         return NULL;
 325                 n = &hw->vt_nodes[node_index];
 326
 327                 break;
 328         case IPN3KE_TM_NODE_LEVEL_COS:
 329                 if (node_index >= IPN3KE_TM_COS_NODE_NUM)
 330                         return NULL;
 331                 n = &hw->cos_nodes[node_index];
 332
 333                 break;
 334         default:
 335                 return NULL;
 336         }
 337
 338         /* Check tm node status */
 339         if (n->node_state == IPN3KE_TM_NODE_STATE_IDLE) {
 340                 if (n->tm_id != RTE_TM_NODE_ID_NULL ||
 341                 n->parent_node_id != RTE_TM_NODE_ID_NULL ||
 342                 n->parent_node != NULL ||
 343                 n->n_children > 0) {
 344                         IPN3KE_AFU_PMD_ERR("tm node check error %d", 1);
 345                 }
 346         } else if (n->node_state < IPN3KE_TM_NODE_STATE_MAX) {
 347                 if (n->tm_id == RTE_TM_NODE_ID_NULL ||
 348                 (level_of_node_id != IPN3KE_TM_NODE_LEVEL_PORT &&
 349                         n->parent_node_id == RTE_TM_NODE_ID_NULL) ||
 350                 (level_of_node_id != IPN3KE_TM_NODE_LEVEL_PORT &&
 351                         n->parent_node == NULL)) {
 352                         IPN3KE_AFU_PMD_ERR("tm node check error %d", 1);
 353                 }
 354         } else {
 355                 IPN3KE_AFU_PMD_ERR("tm node check error %d", 1);
 356         }
 357
 358         if (IPN3KE_BIT_ISSET(state_mask, n->node_state)) {
 359                 if (n->node_state == IPN3KE_TM_NODE_STATE_IDLE)
 360                         return n;
 361                 else if (n->tm_id == tm_id)
 362                         return n;
 363                 else
 364                         return NULL;
 365         } else {
 366                 return NULL;
 367         }
 368 }
 369
 370 /* Traffic manager node type get */
 371 static int
 372 ipn3ke_pmd_tm_node_type_get(struct rte_eth_dev *dev,
 373         uint32_t node_id, int *is_leaf, struct rte_tm_error *error)
 374 {
 375         struct ipn3ke_hw *hw = IPN3KE_DEV_PRIVATE_TO_HW(dev);
 376         struct ipn3ke_tm_internals *tm = IPN3KE_DEV_PRIVATE_TO_TM(dev);
 377         uint32_t tm_id;
 378         struct ipn3ke_tm_node *node;
 379         uint32_t state_mask;
 380
 381         if (is_leaf == NULL)
 382                 return -rte_tm_error_set(error,
 383                                         EINVAL,
 384                                         RTE_TM_ERROR_TYPE_UNSPECIFIED,
 385                                         NULL,
 386                                         rte_strerror(EINVAL));
 387
 388         tm_id = tm->tm_id;
 389
 390         state_mask = 0;
 391         IPN3KE_BIT_SET(state_mask, IPN3KE_TM_NODE_STATE_COMMITTED);
 392         node = ipn3ke_hw_tm_node_search(hw, tm_id, node_id, state_mask);
 393         if (node_id == RTE_TM_NODE_ID_NULL ||
 394                 node == NULL)
 395                 return -rte_tm_error_set(error,
 396                                         EINVAL,
 397                                         RTE_TM_ERROR_TYPE_NODE_ID,
 398                                         NULL,
 399                                         rte_strerror(EINVAL));
 400
 401         *is_leaf = (node->level == IPN3KE_TM_NODE_LEVEL_COS) ? 1 : 0;
 402
 403         return 0;
 404 }
 405
 406 #define WRED_SUPPORTED    0
 407
 408 #define STATS_MASK_DEFAULT \
 409         (RTE_TM_STATS_N_PKTS | \
 410         RTE_TM_STATS_N_BYTES | \
 411         RTE_TM_STATS_N_PKTS_GREEN_DROPPED | \
 412         RTE_TM_STATS_N_BYTES_GREEN_DROPPED)
 413
 414 #define STATS_MASK_QUEUE \
 415         (STATS_MASK_DEFAULT | RTE_TM_STATS_N_PKTS_QUEUED)
 416
 417 /* Traffic manager capabilities get */
 418 static int
 419 ipn3ke_tm_capabilities_get(__rte_unused struct rte_eth_dev *dev,
 420         struct rte_tm_capabilities *cap, struct rte_tm_error *error)
 421 {
 422         if (cap == NULL)
 423                 return -rte_tm_error_set(error,
 424                                         EINVAL,
 425                                         RTE_TM_ERROR_TYPE_CAPABILITIES,
 426                                         NULL,
 427                                         rte_strerror(EINVAL));
 428
 429         /* set all the parameters to 0 first. */
 430         memset(cap, 0, sizeof(*cap));
 431
 432         cap->n_nodes_max = 1 + IPN3KE_TM_COS_NODE_NUM + IPN3KE_TM_VT_NODE_NUM;
 433         cap->n_levels_max = IPN3KE_TM_NODE_LEVEL_MAX;
 434
 435         cap->non_leaf_nodes_identical = 0;
 436         cap->leaf_nodes_identical = 1;
 437
 438         cap->shaper_n_max = 1 + IPN3KE_TM_VT_NODE_NUM;
 439         cap->shaper_private_n_max = 1 + IPN3KE_TM_VT_NODE_NUM;
 440         cap->shaper_private_dual_rate_n_max = 0;
 441         cap->shaper_private_rate_min = 1;
 442         cap->shaper_private_rate_max = 1 + IPN3KE_TM_VT_NODE_NUM;
 443
 444         cap->shaper_shared_n_max = 0;
 445         cap->shaper_shared_n_nodes_per_shaper_max = 0;
 446         cap->shaper_shared_n_shapers_per_node_max = 0;
 447         cap->shaper_shared_dual_rate_n_max = 0;
 448         cap->shaper_shared_rate_min = 0;
 449         cap->shaper_shared_rate_max = 0;
 450
 451         cap->shaper_pkt_length_adjust_min = RTE_TM_ETH_FRAMING_OVERHEAD_FCS;
 452         cap->shaper_pkt_length_adjust_max = RTE_TM_ETH_FRAMING_OVERHEAD_FCS;
 453
 454         cap->sched_n_children_max = IPN3KE_TM_COS_NODE_NUM;
 455         cap->sched_sp_n_priorities_max = 3;
 456         cap->sched_wfq_n_children_per_group_max = UINT32_MAX;
 457         cap->sched_wfq_n_groups_max = 1;
 458         cap->sched_wfq_weight_max = UINT32_MAX;
 459
 460         cap->cman_wred_packet_mode_supported = 0;
 461         cap->cman_wred_byte_mode_supported = 0;
 462         cap->cman_head_drop_supported = 0;
 463         cap->cman_wred_context_n_max = 0;
 464         cap->cman_wred_context_private_n_max = 0;
 465         cap->cman_wred_context_shared_n_max = 0;
 466         cap->cman_wred_context_shared_n_nodes_per_context_max = 0;
 467         cap->cman_wred_context_shared_n_contexts_per_node_max = 0;
 468
 469         /**
 470          * cap->mark_vlan_dei_supported = {0, 0, 0};
 471          * cap->mark_ip_ecn_tcp_supported = {0, 0, 0};
 472          * cap->mark_ip_ecn_sctp_supported = {0, 0, 0};
 473          * cap->mark_ip_dscp_supported = {0, 0, 0};
 474          */
 475
 476         cap->dynamic_update_mask = 0;
 477
 478         cap->stats_mask = 0;
 479
 480         return 0;
 481 }
 482
 483 /* Traffic manager level capabilities get */
 484 static int
 485 ipn3ke_tm_level_capabilities_get(struct rte_eth_dev *dev,
 486         uint32_t level_id, struct rte_tm_level_capabilities *cap,
 487         struct rte_tm_error *error)
 488 {
 489         struct ipn3ke_hw *hw = IPN3KE_DEV_PRIVATE_TO_HW(dev);
 490
 491         if (cap == NULL)
 492                 return -rte_tm_error_set(error,
 493                                         EINVAL,
 494                                         RTE_TM_ERROR_TYPE_CAPABILITIES,
 495                                         NULL,
 496                                         rte_strerror(EINVAL));
 497
 498         if (level_id >= IPN3KE_TM_NODE_LEVEL_MAX)
 499                 return -rte_tm_error_set(error,
 500                                         EINVAL,
 501                                         RTE_TM_ERROR_TYPE_LEVEL_ID,
 502                                         NULL,
 503                                         rte_strerror(EINVAL));
 504
 505         /* set all the parameters to 0 first. */
 506         memset(cap, 0, sizeof(*cap));
 507
 508         switch (level_id) {
 509         case IPN3KE_TM_NODE_LEVEL_PORT:
 510                 cap->n_nodes_max = hw->port_num;
 511                 cap->n_nodes_nonleaf_max = IPN3KE_TM_VT_NODE_NUM;
 512                 cap->n_nodes_leaf_max = 0;
 513                 cap->non_leaf_nodes_identical = 0;
 514                 cap->leaf_nodes_identical = 0;
 515
 516                 cap->nonleaf.shaper_private_supported = 0;
 517                 cap->nonleaf.shaper_private_dual_rate_supported = 0;
 518                 cap->nonleaf.shaper_private_rate_min = 1;
 519                 cap->nonleaf.shaper_private_rate_max = UINT32_MAX;
 520                 cap->nonleaf.shaper_shared_n_max = 0;
 521
 522                 cap->nonleaf.sched_n_children_max = IPN3KE_TM_VT_NODE_NUM;
 523                 cap->nonleaf.sched_sp_n_priorities_max = 1;
 524                 cap->nonleaf.sched_wfq_n_children_per_group_max = 0;
 525                 cap->nonleaf.sched_wfq_n_groups_max = 0;
 526                 cap->nonleaf.sched_wfq_weight_max = 0;
 527
 528                 cap->nonleaf.stats_mask = STATS_MASK_DEFAULT;
 529                 break;
 530
 531         case IPN3KE_TM_NODE_LEVEL_VT:
 532                 cap->n_nodes_max = IPN3KE_TM_VT_NODE_NUM;
 533                 cap->n_nodes_nonleaf_max = IPN3KE_TM_COS_NODE_NUM;
 534                 cap->n_nodes_leaf_max = 0;
 535                 cap->non_leaf_nodes_identical = 0;
 536                 cap->leaf_nodes_identical = 0;
 537
 538                 cap->nonleaf.shaper_private_supported = 0;
 539                 cap->nonleaf.shaper_private_dual_rate_supported = 0;
 540                 cap->nonleaf.shaper_private_rate_min = 1;
 541                 cap->nonleaf.shaper_private_rate_max = UINT32_MAX;
 542                 cap->nonleaf.shaper_shared_n_max = 0;
 543
 544                 cap->nonleaf.sched_n_children_max = IPN3KE_TM_COS_NODE_NUM;
 545                 cap->nonleaf.sched_sp_n_priorities_max = 1;
 546                 cap->nonleaf.sched_wfq_n_children_per_group_max = 0;
 547                 cap->nonleaf.sched_wfq_n_groups_max = 0;
 548                 cap->nonleaf.sched_wfq_weight_max = 0;
 549
 550                 cap->nonleaf.stats_mask = STATS_MASK_DEFAULT;
 551                 break;
 552
 553         case IPN3KE_TM_NODE_LEVEL_COS:
 554                 cap->n_nodes_max = IPN3KE_TM_COS_NODE_NUM;
 555                 cap->n_nodes_nonleaf_max = 0;
 556                 cap->n_nodes_leaf_max = IPN3KE_TM_COS_NODE_NUM;
 557                 cap->non_leaf_nodes_identical = 0;
 558                 cap->leaf_nodes_identical = 0;
 559
 560                 cap->leaf.shaper_private_supported = 0;
 561                 cap->leaf.shaper_private_dual_rate_supported = 0;
 562                 cap->leaf.shaper_private_rate_min = 0;
 563                 cap->leaf.shaper_private_rate_max = 0;
 564                 cap->leaf.shaper_shared_n_max = 0;
 565
 566                 cap->leaf.cman_head_drop_supported = 0;
 567                 cap->leaf.cman_wred_packet_mode_supported = WRED_SUPPORTED;
 568                 cap->leaf.cman_wred_byte_mode_supported = 0;
 569                 cap->leaf.cman_wred_context_private_supported = WRED_SUPPORTED;
 570                 cap->leaf.cman_wred_context_shared_n_max = 0;
 571
 572                 cap->leaf.stats_mask = STATS_MASK_QUEUE;
 573                 break;
 574
 575         default:
 576                 return -rte_tm_error_set(error,
 577                                         EINVAL,
 578                                         RTE_TM_ERROR_TYPE_LEVEL_ID,
 579                                         NULL,
 580                                         rte_strerror(EINVAL));
 581                 break;
 582         }
 583
 584         return 0;
 585 }
 586
 587 /* Traffic manager node capabilities get */
 588 static int
 589 ipn3ke_tm_node_capabilities_get(struct rte_eth_dev *dev,
 590         uint32_t node_id, struct rte_tm_node_capabilities *cap,
 591         struct rte_tm_error *error)
 592 {
 593         struct ipn3ke_rpst *representor = IPN3KE_DEV_PRIVATE_TO_RPST(dev);
 594         struct ipn3ke_hw *hw = IPN3KE_DEV_PRIVATE_TO_HW(dev);
 595         struct ipn3ke_tm_internals *tm = IPN3KE_DEV_PRIVATE_TO_TM(dev);
 596         uint32_t tm_id;
 597         struct ipn3ke_tm_node *tm_node;
 598         uint32_t state_mask;
 599
 600         if (cap == NULL)
 601                 return -rte_tm_error_set(error,
 602                                         EINVAL,
 603                                         RTE_TM_ERROR_TYPE_CAPABILITIES,
 604                                         NULL,
 605                                         rte_strerror(EINVAL));
 606
 607         tm_id = tm->tm_id;
 608
 609         state_mask = 0;
 610         IPN3KE_BIT_SET(state_mask, IPN3KE_TM_NODE_STATE_COMMITTED);
 611         tm_node = ipn3ke_hw_tm_node_search(hw, tm_id, node_id, state_mask);
 612         if (tm_node == NULL)
 613                 return -rte_tm_error_set(error,
 614                                         EINVAL,
 615                                         RTE_TM_ERROR_TYPE_NODE_ID,
 616                                         NULL,
 617                                         rte_strerror(EINVAL));
 618
 619         if (tm_node->tm_id != representor->port_id)
 620                 return -rte_tm_error_set(error,
 621                                         EINVAL,
 622                                         RTE_TM_ERROR_TYPE_NODE_ID,
 623                                         NULL,
 624                                         rte_strerror(EINVAL));
 625
 626         /* set all the parameters to 0 first. */
 627         memset(cap, 0, sizeof(*cap));
 628
 629         switch (tm_node->level) {
 630         case IPN3KE_TM_NODE_LEVEL_PORT:
 631                 cap->shaper_private_supported = 1;
 632                 cap->shaper_private_dual_rate_supported = 0;
 633                 cap->shaper_private_rate_min = 1;
 634                 cap->shaper_private_rate_max = UINT32_MAX;
 635                 cap->shaper_shared_n_max = 0;
 636
 637                 cap->nonleaf.sched_n_children_max = IPN3KE_TM_VT_NODE_NUM;
 638                 cap->nonleaf.sched_sp_n_priorities_max = 1;
 639                 cap->nonleaf.sched_wfq_n_children_per_group_max =
 640                         IPN3KE_TM_VT_NODE_NUM;
 641                 cap->nonleaf.sched_wfq_n_groups_max = 1;
 642                 cap->nonleaf.sched_wfq_weight_max = 1;
 643
 644                 cap->stats_mask = STATS_MASK_DEFAULT;
 645                 break;
 646
 647         case IPN3KE_TM_NODE_LEVEL_VT:
 648                 cap->shaper_private_supported = 1;
 649                 cap->shaper_private_dual_rate_supported = 0;
 650                 cap->shaper_private_rate_min = 1;
 651                 cap->shaper_private_rate_max = UINT32_MAX;
 652                 cap->shaper_shared_n_max = 0;
 653
 654                 cap->nonleaf.sched_n_children_max = IPN3KE_TM_COS_NODE_NUM;
 655                 cap->nonleaf.sched_sp_n_priorities_max = 1;
 656                 cap->nonleaf.sched_wfq_n_children_per_group_max =
 657                         IPN3KE_TM_COS_NODE_NUM;
 658                 cap->nonleaf.sched_wfq_n_groups_max = 1;
 659                 cap->nonleaf.sched_wfq_weight_max = 1;
 660
 661                 cap->stats_mask = STATS_MASK_DEFAULT;
 662                 break;
 663
 664         case IPN3KE_TM_NODE_LEVEL_COS:
 665                 cap->shaper_private_supported = 0;
 666                 cap->shaper_private_dual_rate_supported = 0;
 667                 cap->shaper_private_rate_min = 0;
 668                 cap->shaper_private_rate_max = 0;
 669                 cap->shaper_shared_n_max = 0;
 670
 671                 cap->leaf.cman_head_drop_supported = 0;
 672                 cap->leaf.cman_wred_packet_mode_supported = WRED_SUPPORTED;
 673                 cap->leaf.cman_wred_byte_mode_supported = 0;
 674                 cap->leaf.cman_wred_context_private_supported = WRED_SUPPORTED;
 675                 cap->leaf.cman_wred_context_shared_n_max = 0;
 676
 677                 cap->stats_mask = STATS_MASK_QUEUE;
 678                 break;
 679         default:
 680                 break;
 681         }
 682
 683         return 0;
 684 }
 685
 686 static int
 687 ipn3ke_tm_shaper_parame_trans(struct rte_tm_shaper_params *profile,
 688         struct ipn3ke_tm_shaper_profile *local_profile,
 689         const struct ipn3ke_tm_shaper_params_range_type *ref_data)
 690 {
 691         uint32_t i;
 692         const struct ipn3ke_tm_shaper_params_range_type *r;
 693         uint64_t rate;
 694
 695         rate = profile->peak.rate;
 696         for (i = 0, r = ref_data; i < IPN3KE_TM_SHAPER_RANGE_NUM; i++, r++) {
 697                 if (rate >= r->low &&
 698                 rate <= r->high) {
 699                         local_profile->m = (rate / 4) / r->exp2;
 700                         local_profile->e = r->exp;
 701                         local_profile->rate = rate;
 702
 703                         return 0;
 704                 }
 705         }
 706
 707         return -1;
 708 }
 709
 710 static int
 711 ipn3ke_tm_shaper_profile_add(struct rte_eth_dev *dev,
 712         uint32_t shaper_profile_id, struct rte_tm_shaper_params *profile,
 713         struct rte_tm_error *error)
 714 {
 715         struct ipn3ke_hw *hw = IPN3KE_DEV_PRIVATE_TO_HW(dev);
 716         struct ipn3ke_tm_internals *tm = IPN3KE_DEV_PRIVATE_TO_TM(dev);
 717         struct ipn3ke_tm_shaper_profile *sp;
 718
 719         /* Shaper profile must not exist. */
 720         sp = ipn3ke_hw_tm_shaper_profile_search(hw, shaper_profile_id, error);
 721         if (!sp || (sp && sp->valid))
 722                 return -rte_tm_error_set(error,
 723                                         EEXIST,
 724                                         RTE_TM_ERROR_TYPE_SHAPER_PROFILE_ID,
 725                                         NULL,
 726                                         rte_strerror(EEXIST));
 727
 728         /* Profile must not be NULL. */
 729         if (profile == NULL)
 730                 return -rte_tm_error_set(error,
 731                                         EINVAL,
 732                                         RTE_TM_ERROR_TYPE_SHAPER_PROFILE,
 733                                         NULL,
 734                                         rte_strerror(EINVAL));
 735
 736         /* Peak rate: non-zero, 32-bit */
 737         if (profile->peak.rate == 0 ||
 738                 profile->peak.rate > IPN3KE_TM_SHAPER_PEAK_RATE_MAX)
 739                 return -rte_tm_error_set(error,
 740                                 EINVAL,
 741                                 RTE_TM_ERROR_TYPE_SHAPER_PROFILE_PEAK_RATE,
 742                                 NULL,
 743                                 rte_strerror(EINVAL));
 744
 745         /* Peak size: non-zero, 32-bit */
 746         if (profile->peak.size != 0)
 747                 return -rte_tm_error_set(error,
 748                                 EINVAL,
 749                                 RTE_TM_ERROR_TYPE_SHAPER_PROFILE_PEAK_SIZE,
 750                                 NULL,
 751                                 rte_strerror(EINVAL));
 752
 753         /* Dual-rate profiles are not supported. */
 754         if (profile->committed.rate > IPN3KE_TM_SHAPER_COMMITTED_RATE_MAX)
 755                 return -rte_tm_error_set(error,
 756                                 EINVAL,
 757                                 RTE_TM_ERROR_TYPE_SHAPER_PROFILE_COMMITTED_RATE,
 758                                 NULL,
 759                                 rte_strerror(EINVAL));
 760
 761         /* Packet length adjust: 24 bytes */
 762         if (profile->pkt_length_adjust != 0)
 763                 return -rte_tm_error_set(error,
 764                                 EINVAL,
 765                                 RTE_TM_ERROR_TYPE_SHAPER_PROFILE_PKT_ADJUST_LEN,
 766                                 NULL,
 767                                 rte_strerror(EINVAL));
 768
 769         if (ipn3ke_tm_shaper_parame_trans(profile,
 770                                         sp,
 771                                         ipn3ke_tm_shaper_params_rang)) {
 772                 return -rte_tm_error_set(error,
 773                                 EINVAL,
 774                                 RTE_TM_ERROR_TYPE_SHAPER_PROFILE_PEAK_RATE,
 775                                 NULL,
 776                                 rte_strerror(EINVAL));
 777         } else {
 778                 sp->valid = 1;
 779                 rte_memcpy(&sp->params, profile, sizeof(sp->params));
 780         }
 781
 782         tm->h.n_shaper_profiles++;
 783
 784         return 0;
 785 }
 786
 787 /* Traffic manager shaper profile delete */
 788 static int
 789 ipn3ke_tm_shaper_profile_delete(struct rte_eth_dev *dev,
 790         uint32_t shaper_profile_id, struct rte_tm_error *error)
 791 {
 792         struct ipn3ke_hw *hw = IPN3KE_DEV_PRIVATE_TO_HW(dev);
 793         struct ipn3ke_tm_internals *tm = IPN3KE_DEV_PRIVATE_TO_TM(dev);
 794         struct ipn3ke_tm_shaper_profile *sp;
 795
 796         /* Check existing */
 797         sp = ipn3ke_hw_tm_shaper_profile_search(hw, shaper_profile_id, error);
 798         if (!sp || (sp && !sp->valid))
 799                 return -rte_tm_error_set(error,
 800                                         EINVAL,
 801                                         RTE_TM_ERROR_TYPE_SHAPER_PROFILE_ID,
 802                                         NULL,
 803                                         rte_strerror(EINVAL));
 804
 805         sp->valid = 0;
 806         tm->h.n_shaper_profiles--;
 807
 808         return 0;
 809 }
 810
 811 static int
 812 ipn3ke_tm_tdrop_profile_check(__rte_unused struct rte_eth_dev *dev,
 813         uint32_t tdrop_profile_id, struct rte_tm_wred_params *profile,
 814         struct rte_tm_error *error)
 815 {
 816         enum rte_color color;
 817
 818         /* TDROP profile ID must not be NONE. */
 819         if (tdrop_profile_id == RTE_TM_WRED_PROFILE_ID_NONE)
 820                 return -rte_tm_error_set(error,
 821                                         EINVAL,
 822                                         RTE_TM_ERROR_TYPE_WRED_PROFILE_ID,
 823                                         NULL,
 824                                         rte_strerror(EINVAL));
 825
 826         /* Profile must not be NULL. */
 827         if (profile == NULL)
 828                 return -rte_tm_error_set(error,
 829                                         EINVAL,
 830                                         RTE_TM_ERROR_TYPE_WRED_PROFILE,
 831                                         NULL,
 832                                         rte_strerror(EINVAL));
 833
 834         /* TDROP profile should be in packet mode */
 835         if (profile->packet_mode != 0)
 836                 return -rte_tm_error_set(error,
 837                                         ENOTSUP,
 838                                         RTE_TM_ERROR_TYPE_WRED_PROFILE,
 839                                         NULL,
 840                                         rte_strerror(ENOTSUP));
 841
 842         /* min_th <= max_th, max_th > 0  */
 843         for (color = RTE_COLOR_GREEN; color <= RTE_COLOR_GREEN; color++) {
 844                 uint64_t min_th = profile->red_params[color].min_th;
 845                 uint64_t max_th = profile->red_params[color].max_th;
 846
 847                 if (((min_th >> IPN3KE_TDROP_TH1_SHIFT) >>
 848                                 IPN3KE_TDROP_TH1_SHIFT) ||
 849                         max_th != 0)
 850                         return -rte_tm_error_set(error,
 851                                                 EINVAL,
 852                                                 RTE_TM_ERROR_TYPE_WRED_PROFILE,
 853                                                 NULL,
 854                                                 rte_strerror(EINVAL));
 855         }
 856
 857         return 0;
 858 }
 859
 860 static int
 861 ipn3ke_hw_tm_tdrop_wr(struct ipn3ke_hw *hw,
 862                                 struct ipn3ke_tm_tdrop_profile *tp)
 863 {
 864         if (tp->valid) {
 865                 IPN3KE_MASK_WRITE_REG(hw,
 866                                 IPN3KE_CCB_PROFILE_MS,
 867                                 0,
 868                                 tp->th2,
 869                                 IPN3KE_CCB_PROFILE_MS_MASK);
 870
 871                 IPN3KE_MASK_WRITE_REG(hw,
 872                                 IPN3KE_CCB_PROFILE_P,
 873                                 tp->tdrop_profile_id,
 874                                 tp->th1,
 875                                 IPN3KE_CCB_PROFILE_MASK);
 876         } else {
 877                 IPN3KE_MASK_WRITE_REG(hw,
 878                                 IPN3KE_CCB_PROFILE_MS,
 879                                 0,
 880                                 0,
 881                                 IPN3KE_CCB_PROFILE_MS_MASK);
 882
 883                 IPN3KE_MASK_WRITE_REG(hw,
 884                                 IPN3KE_CCB_PROFILE_P,
 885                                 tp->tdrop_profile_id,
 886                                 0,
 887                                 IPN3KE_CCB_PROFILE_MASK);
 888         }
 889
 890         return 0;
 891 }
 892
 893 /* Traffic manager TDROP profile add */
 894 static int
 895 ipn3ke_tm_tdrop_profile_add(struct rte_eth_dev *dev,
 896         uint32_t tdrop_profile_id, struct rte_tm_wred_params *profile,
 897         struct rte_tm_error *error)
 898 {
 899         struct ipn3ke_hw *hw = IPN3KE_DEV_PRIVATE_TO_HW(dev);
 900         struct ipn3ke_tm_internals *tm = IPN3KE_DEV_PRIVATE_TO_TM(dev);
 901         struct ipn3ke_tm_tdrop_profile *tp;
 902         int status;
 903         uint64_t min_th;
 904         uint32_t th1, th2;
 905
 906         /* Check input params */
 907         status = ipn3ke_tm_tdrop_profile_check(dev,
 908                                         tdrop_profile_id,
 909                                         profile,
 910                                         error);
 911         if (status)
 912                 return status;
 913
 914         /* Memory allocation */
 915         tp = &hw->tdrop_profile[tdrop_profile_id];
 916
 917         /* Fill in */
 918         tp->valid = 1;
 919         min_th = profile->red_params[RTE_COLOR_GREEN].min_th;
 920         th1 = (uint32_t)(min_th & IPN3KE_TDROP_TH1_MASK);
 921         th2 = (uint32_t)((min_th >> IPN3KE_TDROP_TH1_SHIFT) &
 922                         IPN3KE_TDROP_TH2_MASK);
 923         tp->th1 = th1;
 924         tp->th2 = th2;
 925         rte_memcpy(&tp->params, profile, sizeof(tp->params));
 926
 927         /* Add to list */
 928         tm->h.n_tdrop_profiles++;
 929
 930         /* Write FPGA */
 931         ipn3ke_hw_tm_tdrop_wr(hw, tp);
 932
 933         return 0;
 934 }
 935
 936 /* Traffic manager TDROP profile delete */
 937 static int
 938 ipn3ke_tm_tdrop_profile_delete(struct rte_eth_dev *dev,
 939         uint32_t tdrop_profile_id, struct rte_tm_error *error)
 940 {
 941         struct ipn3ke_hw *hw = IPN3KE_DEV_PRIVATE_TO_HW(dev);
 942         struct ipn3ke_tm_internals *tm = IPN3KE_DEV_PRIVATE_TO_TM(dev);
 943         struct ipn3ke_tm_tdrop_profile *tp;
 944
 945         /* Check existing */
 946         tp = ipn3ke_hw_tm_tdrop_profile_search(hw, tdrop_profile_id);
 947         if (tp == NULL)
 948                 return -rte_tm_error_set(error,
 949                                         EINVAL,
 950                                         RTE_TM_ERROR_TYPE_WRED_PROFILE_ID,
 951                                         NULL,
 952                                         rte_strerror(EINVAL));
 953
 954         /* Check unused */
 955         if (tp->n_users)
 956                 return -rte_tm_error_set(error,
 957                                         EBUSY,
 958                                         RTE_TM_ERROR_TYPE_WRED_PROFILE_ID,
 959                                         NULL,
 960                                         rte_strerror(EBUSY));
 961
 962         /* Set free */
 963         tp->valid = 0;
 964         tm->h.n_tdrop_profiles--;
 965
 966         /* Write FPGA */
 967         ipn3ke_hw_tm_tdrop_wr(hw, tp);
 968
 969         return 0;
 970 }
 971
 972 static int
 973 ipn3ke_tm_node_add_check_parameter(uint32_t tm_id,
 974         uint32_t node_id, uint32_t parent_node_id, uint32_t priority,
 975         uint32_t weight, uint32_t level_id, struct rte_tm_node_params *params,
 976         struct rte_tm_error *error)
 977 {
 978         uint32_t level_of_node_id;
 979         uint32_t node_index;
 980         uint32_t parent_level_id;
 981
 982         if (node_id == RTE_TM_NODE_ID_NULL)
 983                 return -rte_tm_error_set(error,
 984                                         EINVAL,
 985                                         RTE_TM_ERROR_TYPE_NODE_ID,
 986                                         NULL,
 987                                         rte_strerror(EINVAL));
 988
 989         /* priority: must be 0, 1, 2, 3 */
 990         if (priority > IPN3KE_TM_NODE_PRIORITY_HIGHEST)
 991                 return -rte_tm_error_set(error,
 992                                         EINVAL,
 993                                         RTE_TM_ERROR_TYPE_NODE_PRIORITY,
 994                                         NULL,
 995                                         rte_strerror(EINVAL));
 996
 997         /* weight: must be 1 .. 255 */
 998         if (weight > IPN3KE_TM_NODE_WEIGHT_MAX)
 999                 return -rte_tm_error_set(error,
1000                                         EINVAL,
1001                                         RTE_TM_ERROR_TYPE_NODE_WEIGHT,
1002                                         NULL,
1003                                         rte_strerror(EINVAL));
1004
1005         /* check node id and parent id*/
1006         level_of_node_id = node_id / IPN3KE_TM_NODE_LEVEL_MOD;
1007         if (level_of_node_id != level_id)
1008                 return -rte_tm_error_set(error,
1009                                         EINVAL,
1010                                         RTE_TM_ERROR_TYPE_NODE_ID,
1011                                         NULL,
1012                                         rte_strerror(EINVAL));
1013         node_index = node_id % IPN3KE_TM_NODE_LEVEL_MOD;
1014         parent_level_id = parent_node_id / IPN3KE_TM_NODE_LEVEL_MOD;
1015         switch (level_id) {
1016         case IPN3KE_TM_NODE_LEVEL_PORT:
1017                 if (node_index != tm_id)
1018                         return -rte_tm_error_set(error,
1019                                                 EINVAL,
1020                                                 RTE_TM_ERROR_TYPE_NODE_ID,
1021                                                 NULL,
1022                                                 rte_strerror(EINVAL));
1023                 if (parent_node_id != RTE_TM_NODE_ID_NULL)
1024                         return -rte_tm_error_set(error,
1025                                         EINVAL,
1026                                         RTE_TM_ERROR_TYPE_NODE_PARENT_NODE_ID,
1027                                         NULL,
1028                                         rte_strerror(EINVAL));
1029                 break;
1030
1031         case IPN3KE_TM_NODE_LEVEL_VT:
1032                 if (node_index >= IPN3KE_TM_VT_NODE_NUM)
1033                         return -rte_tm_error_set(error,
1034                                                 EINVAL,
1035                                                 RTE_TM_ERROR_TYPE_NODE_ID,
1036                                                 NULL,
1037                                                 rte_strerror(EINVAL));
1038                 if (parent_level_id != IPN3KE_TM_NODE_LEVEL_PORT)
1039                         return -rte_tm_error_set(error,
1040                                         EINVAL,
1041                                         RTE_TM_ERROR_TYPE_NODE_PARENT_NODE_ID,
1042                                         NULL,
1043                                         rte_strerror(EINVAL));
1044                 break;
1045
1046         case IPN3KE_TM_NODE_LEVEL_COS:
1047                 if (node_index >= IPN3KE_TM_COS_NODE_NUM)
1048                         return -rte_tm_error_set(error,
1049                                                 EINVAL,
1050                                                 RTE_TM_ERROR_TYPE_NODE_ID,
1051                                                 NULL,
1052                                                 rte_strerror(EINVAL));
1053                 if (parent_level_id != IPN3KE_TM_NODE_LEVEL_VT)
1054                         return -rte_tm_error_set(error,
1055                                         EINVAL,
1056                                         RTE_TM_ERROR_TYPE_NODE_PARENT_NODE_ID,
1057                                         NULL,
1058                                         rte_strerror(EINVAL));
1059                 break;
1060         default:
1061                 return -rte_tm_error_set(error,
1062                                         EINVAL,
1063                                         RTE_TM_ERROR_TYPE_LEVEL_ID,
1064                                         NULL,
1065                                         rte_strerror(EINVAL));
1066         }
1067
1068         /* params: must not be NULL */
1069         if (params == NULL)
1070                 return -rte_tm_error_set(error,
1071                                         EINVAL,
1072                                         RTE_TM_ERROR_TYPE_NODE_PARAMS,
1073                                         NULL,
1074                                         rte_strerror(EINVAL));
1075         /* No shared shapers */
1076         if (params->n_shared_shapers != 0)
1077                 return -rte_tm_error_set(error,
1078                                 EINVAL,
1079                                 RTE_TM_ERROR_TYPE_NODE_PARAMS_N_SHARED_SHAPERS,
1080                                 NULL,
1081                                 rte_strerror(EINVAL));
1082         return 0;
1083 }
1084
1085 static int
1086 ipn3ke_tm_node_add_check_mount(uint32_t tm_id,
1087         uint32_t node_id, uint32_t parent_node_id, uint32_t level_id,
1088         struct rte_tm_error *error)
1089 {
1090         /*struct ipn3ke_tm_internals *tm = IPN3KE_DEV_PRIVATE_TO_TM(dev);*/
1091         uint32_t node_index;
1092         uint32_t parent_index;
1093         uint32_t parent_index1;
1094
1095         node_index = node_id % IPN3KE_TM_NODE_LEVEL_MOD;
1096         parent_index = parent_node_id % IPN3KE_TM_NODE_LEVEL_MOD;
1097         parent_index1 = node_index / IPN3KE_TM_NODE_MOUNT_MAX;
1098         switch (level_id) {
1099         case IPN3KE_TM_NODE_LEVEL_PORT:
1100                 break;
1101
1102         case IPN3KE_TM_NODE_LEVEL_VT:
1103                 if (parent_index != tm_id)
1104                         return -rte_tm_error_set(error,
1105                                         EINVAL,
1106                                         RTE_TM_ERROR_TYPE_NODE_PARENT_NODE_ID,
1107                                         NULL,
1108                                         rte_strerror(EINVAL));
1109                 break;
1110
1111         case IPN3KE_TM_NODE_LEVEL_COS:
1112                 if (parent_index != parent_index1)
1113                         return -rte_tm_error_set(error,
1114                                         EINVAL,
1115                                         RTE_TM_ERROR_TYPE_NODE_PARENT_NODE_ID,
1116                                         NULL,
1117                                         rte_strerror(EINVAL));
1118                 break;
1119         default:
1120                 return -rte_tm_error_set(error,
1121                                         EINVAL,
1122                                         RTE_TM_ERROR_TYPE_LEVEL_ID,
1123                                         NULL,
1124                                         rte_strerror(EINVAL));
1125         }
1126
1127         return 0;
1128 }
1129
1130 /* Traffic manager node add */
1131 static int
1132 ipn3ke_tm_node_add(struct rte_eth_dev *dev,
1133         uint32_t node_id, uint32_t parent_node_id, uint32_t priority,
1134         uint32_t weight, uint32_t level_id, struct rte_tm_node_params *params,
1135         struct rte_tm_error *error)
1136 {
1137         struct ipn3ke_hw *hw = IPN3KE_DEV_PRIVATE_TO_HW(dev);
1138         struct ipn3ke_tm_internals *tm = IPN3KE_DEV_PRIVATE_TO_TM(dev);
1139         uint32_t tm_id;
1140         struct ipn3ke_tm_node *n, *parent_node;
1141         uint32_t node_state, state_mask;
1142         int status;
1143
1144         /* Checks */
1145         if (tm->hierarchy_frozen)
1146                 return -rte_tm_error_set(error,
1147                                         EBUSY,
1148                                         RTE_TM_ERROR_TYPE_UNSPECIFIED,
1149                                         NULL,
1150                                         rte_strerror(EBUSY));
1151
1152         tm_id = tm->tm_id;
1153
1154         status = ipn3ke_tm_node_add_check_parameter(tm_id,
1155                                                 node_id,
1156                                                 parent_node_id,
1157                                                 priority,
1158                                                 weight,
1159                                                 level_id,
1160                                                 params,
1161                                                 error);
1162         if (status)
1163                 return status;
1164
1165         status = ipn3ke_tm_node_add_check_mount(tm_id,
1166                                                 node_id,
1167                                                 parent_node_id,
1168                                                 level_id,
1169                                                 error);
1170         if (status)
1171                 return status;
1172
1173         /* Shaper profile ID must not be NONE. */
1174         if (params->shaper_profile_id != RTE_TM_SHAPER_PROFILE_ID_NONE &&
1175                 params->shaper_profile_id != node_id)
1176                 return -rte_tm_error_set(error,
1177                                         EINVAL,
1178                                         RTE_TM_ERROR_TYPE_SHAPER_PROFILE_ID,
1179                                         NULL,
1180                                         rte_strerror(EINVAL));
1181
1182         /* Memory allocation */
1183         state_mask = 0;
1184         IPN3KE_BIT_SET(state_mask, IPN3KE_TM_NODE_STATE_IDLE);
1185         IPN3KE_BIT_SET(state_mask, IPN3KE_TM_NODE_STATE_CONFIGURED_DEL);
1186         n = ipn3ke_hw_tm_node_search(hw, tm_id, node_id, state_mask);
1187         if (!n)
1188                 return -rte_tm_error_set(error,
1189                                         EINVAL,
1190                                         RTE_TM_ERROR_TYPE_UNSPECIFIED,
1191                                         NULL,
1192                                         rte_strerror(EINVAL));
1193         node_state = n->node_state;
1194
1195         /* Check parent node */
1196         state_mask = 0;
1197         IPN3KE_BIT_SET(state_mask, IPN3KE_TM_NODE_STATE_CONFIGURED_ADD);
1198         IPN3KE_BIT_SET(state_mask, IPN3KE_TM_NODE_STATE_COMMITTED);
1199         if (parent_node_id != RTE_TM_NODE_ID_NULL) {
1200                 parent_node = ipn3ke_hw_tm_node_search(hw,
1201                                                         tm_id,
1202                                                         parent_node_id,
1203                                                         state_mask);
1204                 if (!parent_node)
1205                         return -rte_tm_error_set(error,
1206                                         EINVAL,
1207                                         RTE_TM_ERROR_TYPE_NODE_PARENT_NODE_ID,
1208                                         NULL,
1209                                         rte_strerror(EINVAL));
1210         } else {
1211                 parent_node = NULL;
1212         }
1213
1214         switch (level_id) {
1215         case IPN3KE_TM_NODE_LEVEL_PORT:
1216                 n->node_state = IPN3KE_TM_NODE_STATE_CONFIGURED_ADD;
1217                 n->tm_id = tm_id;
1218                 tm->h.port_commit_node = n;
1219                 break;
1220
1221         case IPN3KE_TM_NODE_LEVEL_VT:
1222                 if (node_state == IPN3KE_TM_NODE_STATE_IDLE) {
1223                         TAILQ_INSERT_TAIL(&tm->h.vt_commit_node_list, n, node);
1224                         if (parent_node)
1225                                 parent_node->n_children++;
1226                         tm->h.n_vt_nodes++;
1227                 } else if (node_state == IPN3KE_TM_NODE_STATE_CONFIGURED_DEL) {
1228                         if (parent_node)
1229                                 parent_node->n_children++;
1230                         tm->h.n_vt_nodes++;
1231                 }
1232                 n->node_state = IPN3KE_TM_NODE_STATE_CONFIGURED_ADD;
1233                 n->parent_node_id = parent_node_id;
1234                 n->tm_id = tm_id;
1235                 n->parent_node = parent_node;
1236
1237                 break;
1238
1239         case IPN3KE_TM_NODE_LEVEL_COS:
1240                 if (node_state == IPN3KE_TM_NODE_STATE_IDLE) {
1241                         TAILQ_INSERT_TAIL(&tm->h.cos_commit_node_list,
1242                                 n, node);
1243                         if (parent_node)
1244                                 parent_node->n_children++;
1245                         tm->h.n_cos_nodes++;
1246                 } else if (node_state == IPN3KE_TM_NODE_STATE_CONFIGURED_DEL) {
1247                         if (parent_node)
1248                                 parent_node->n_children++;
1249                         tm->h.n_cos_nodes++;
1250                 }
1251                 n->node_state = IPN3KE_TM_NODE_STATE_CONFIGURED_ADD;
1252                 n->parent_node_id = parent_node_id;
1253                 n->tm_id = tm_id;
1254                 n->parent_node = parent_node;
1255
1256                 break;
1257         default:
1258                 return -rte_tm_error_set(error,
1259                                         EINVAL,
1260                                         RTE_TM_ERROR_TYPE_LEVEL_ID,
1261                                         NULL,
1262                                         rte_strerror(EINVAL));
1263         }
1264
1265         /* Fill in */
1266         n->priority = priority;
1267         n->weight = weight;
1268
1269         if (n->level == IPN3KE_TM_NODE_LEVEL_COS &&
1270                 params->leaf.cman == RTE_TM_CMAN_TAIL_DROP)
1271                 n->tdrop_profile = ipn3ke_hw_tm_tdrop_profile_search(hw,
1272                         params->leaf.wred.wred_profile_id);
1273
1274         rte_memcpy(&n->params, params, sizeof(n->params));
1275
1276         return 0;
1277 }
1278
1279 static int
1280 ipn3ke_tm_node_del_check_parameter(uint32_t tm_id,
1281         uint32_t node_id, struct rte_tm_error *error)
1282 {
1283         uint32_t level_of_node_id;
1284         uint32_t node_index;
1285
1286         if (node_id == RTE_TM_NODE_ID_NULL)
1287                 return -rte_tm_error_set(error,
1288                                         EINVAL,
1289                                         RTE_TM_ERROR_TYPE_NODE_ID,
1290                                         NULL,
1291                                         rte_strerror(EINVAL));
1292
1293         /* check node id and parent id*/
1294         level_of_node_id = node_id / IPN3KE_TM_NODE_LEVEL_MOD;
1295         node_index = node_id % IPN3KE_TM_NODE_LEVEL_MOD;
1296         switch (level_of_node_id) {
1297         case IPN3KE_TM_NODE_LEVEL_PORT:
1298                 if (node_index != tm_id)
1299                         return -rte_tm_error_set(error,
1300                                                 EINVAL,
1301                                                 RTE_TM_ERROR_TYPE_NODE_ID,
1302                                                 NULL,
1303                                                 rte_strerror(EINVAL));
1304                 break;
1305
1306         case IPN3KE_TM_NODE_LEVEL_VT:
1307                 if (node_index >= IPN3KE_TM_VT_NODE_NUM)
1308                         return -rte_tm_error_set(error,
1309                                                 EINVAL,
1310                                                 RTE_TM_ERROR_TYPE_NODE_ID,
1311                                                 NULL,
1312                                                 rte_strerror(EINVAL));
1313                 break;
1314
1315         case IPN3KE_TM_NODE_LEVEL_COS:
1316                 if (node_index >= IPN3KE_TM_COS_NODE_NUM)
1317                         return -rte_tm_error_set(error,
1318                                                 EINVAL,
1319                                                 RTE_TM_ERROR_TYPE_NODE_ID,
1320                                                 NULL,
1321                                                 rte_strerror(EINVAL));
1322                 break;
1323         default:
1324                 return -rte_tm_error_set(error,
1325                                         EINVAL,
1326                                         RTE_TM_ERROR_TYPE_LEVEL_ID,
1327                                         NULL,
1328                                         rte_strerror(EINVAL));
1329         }
1330
1331         return 0;
1332 }
1333
1334 /* Traffic manager node delete */
1335 static int
1336 ipn3ke_pmd_tm_node_delete(struct rte_eth_dev *dev,
1337         uint32_t node_id, struct rte_tm_error *error)
1338 {
1339         struct ipn3ke_hw *hw = IPN3KE_DEV_PRIVATE_TO_HW(dev);
1340         struct ipn3ke_tm_internals *tm = IPN3KE_DEV_PRIVATE_TO_TM(dev);
1341         struct ipn3ke_tm_node *n, *parent_node;
1342         uint32_t tm_id;
1343         int status;
1344         uint32_t level_of_node_id;
1345         uint32_t node_state;
1346         uint32_t state_mask;
1347
1348         /* Check hierarchy changes are currently allowed */
1349         if (tm->hierarchy_frozen)
1350                 return -rte_tm_error_set(error,
1351                                         EBUSY,
1352                                         RTE_TM_ERROR_TYPE_UNSPECIFIED,
1353                                         NULL,
1354                                         rte_strerror(EBUSY));
1355
1356         tm_id = tm->tm_id;
1357
1358         status = ipn3ke_tm_node_del_check_parameter(tm_id,
1359                                                 node_id,
1360                                                 error);
1361         if (status)
1362                 return status;
1363
1364         /* Check existing */
1365         state_mask = 0;
1366         IPN3KE_BIT_SET(state_mask, IPN3KE_TM_NODE_STATE_CONFIGURED_ADD);
1367         IPN3KE_BIT_SET(state_mask, IPN3KE_TM_NODE_STATE_COMMITTED);
1368         n = ipn3ke_hw_tm_node_search(hw, tm_id, node_id, state_mask);
1369         if (n == NULL)
1370                 return -rte_tm_error_set(error,
1371                                         EINVAL,
1372                                         RTE_TM_ERROR_TYPE_NODE_ID,
1373                                         NULL,
1374                                         rte_strerror(EINVAL));
1375
1376         if (n->n_children > 0)
1377                 return -rte_tm_error_set(error,
1378                                         EINVAL,
1379                                         RTE_TM_ERROR_TYPE_NODE_ID,
1380                                         NULL,
1381                                         rte_strerror(EINVAL));
1382
1383         node_state = n->node_state;
1384
1385         level_of_node_id = node_id / IPN3KE_TM_NODE_LEVEL_MOD;
1386
1387         /* Check parent node */
1388         if (n->parent_node_id != RTE_TM_NODE_ID_NULL) {
1389                 state_mask = 0;
1390                 IPN3KE_BIT_SET(state_mask, IPN3KE_TM_NODE_STATE_CONFIGURED_ADD);
1391                 IPN3KE_BIT_SET(state_mask, IPN3KE_TM_NODE_STATE_COMMITTED);
1392                 parent_node = ipn3ke_hw_tm_node_search(hw,
1393                                                 tm_id,
1394                                                 n->parent_node_id,
1395                                                 state_mask);
1396                 if (!parent_node)
1397                         return -rte_tm_error_set(error,
1398                                         EINVAL,
1399                                         RTE_TM_ERROR_TYPE_NODE_PARENT_NODE_ID,
1400                                         NULL,
1401                                         rte_strerror(EINVAL));
1402                 if (n->parent_node != parent_node)
1403                         return -rte_tm_error_set(error,
1404                                                 EINVAL,
1405                                                 RTE_TM_ERROR_TYPE_NODE_ID,
1406                                                 NULL,
1407                                                 rte_strerror(EINVAL));
1408         } else {
1409                 parent_node = NULL;
1410         }
1411
1412         switch (level_of_node_id) {
1413         case IPN3KE_TM_NODE_LEVEL_PORT:
1414                 if (tm->h.port_node != n)
1415                         return -rte_tm_error_set(error,
1416                                                 EINVAL,
1417                                                 RTE_TM_ERROR_TYPE_NODE_ID,
1418                                                 NULL,
1419                                                 rte_strerror(EINVAL));
1420                 n->node_state = IPN3KE_TM_NODE_STATE_CONFIGURED_DEL;
1421                 tm->h.port_commit_node = n;
1422
1423                 break;
1424
1425         case IPN3KE_TM_NODE_LEVEL_VT:
1426                 if (node_state == IPN3KE_TM_NODE_STATE_COMMITTED) {
1427                         if (parent_node)
1428                                 TAILQ_REMOVE(&parent_node->children_node_list,
1429                                         n, node);
1430                         TAILQ_INSERT_TAIL(&tm->h.vt_commit_node_list, n, node);
1431                         if (parent_node)
1432                                 parent_node->n_children--;
1433                         tm->h.n_vt_nodes--;
1434                 } else if (node_state == IPN3KE_TM_NODE_STATE_CONFIGURED_ADD) {
1435                         if (parent_node)
1436                                 parent_node->n_children--;
1437                         tm->h.n_vt_nodes--;
1438                 }
1439                 n->node_state = IPN3KE_TM_NODE_STATE_CONFIGURED_DEL;
1440
1441                 break;
1442
1443         case IPN3KE_TM_NODE_LEVEL_COS:
1444                 if (node_state == IPN3KE_TM_NODE_STATE_COMMITTED) {
1445                         if (parent_node)
1446                                 TAILQ_REMOVE(&parent_node->children_node_list,
1447                                         n, node);
1448                         TAILQ_INSERT_TAIL(&tm->h.cos_commit_node_list,
1449                                 n, node);
1450                         if (parent_node)
1451                                 parent_node->n_children--;
1452                         tm->h.n_cos_nodes--;
1453                 } else if (node_state == IPN3KE_TM_NODE_STATE_CONFIGURED_ADD) {
1454                         if (parent_node)
1455                                 parent_node->n_children--;
1456                         tm->h.n_cos_nodes--;
1457                 }
1458                 n->node_state = IPN3KE_TM_NODE_STATE_CONFIGURED_DEL;
1459
1460                 break;
1461         default:
1462                 return -rte_tm_error_set(error,
1463                                         EINVAL,
1464                                         RTE_TM_ERROR_TYPE_LEVEL_ID,
1465                                         NULL,
1466                                         rte_strerror(EINVAL));
1467         }
1468
1469         return 0;
1470 }
1471
1472 static int
1473 ipn3ke_tm_hierarchy_commit_check(struct rte_eth_dev *dev,
1474                                                 struct rte_tm_error *error)
1475 {
1476         struct ipn3ke_tm_internals *tm = IPN3KE_DEV_PRIVATE_TO_TM(dev);
1477         uint32_t tm_id;
1478         struct ipn3ke_tm_node_list *nl;
1479         struct ipn3ke_tm_node *n, *parent_node;
1480
1481         tm_id = tm->tm_id;
1482
1483         nl = &tm->h.cos_commit_node_list;
1484         TAILQ_FOREACH(n, nl, node) {
1485                 parent_node = n->parent_node;
1486                 if (n->node_state == IPN3KE_TM_NODE_STATE_CONFIGURED_ADD) {
1487                         if (n->parent_node_id == RTE_TM_NODE_ID_NULL ||
1488                                 n->level != IPN3KE_TM_NODE_LEVEL_COS ||
1489                                 n->tm_id != tm_id ||
1490                                 parent_node == NULL ||
1491                                 (parent_node &&
1492                                         parent_node->node_state ==
1493                                         IPN3KE_TM_NODE_STATE_CONFIGURED_DEL) ||
1494                                 (parent_node &&
1495                                         parent_node->node_state ==
1496                                                 IPN3KE_TM_NODE_STATE_IDLE) ||
1497                                 n->shaper_profile.valid == 0) {
1498                                 return -rte_tm_error_set(error,
1499                                                 EINVAL,
1500                                                 RTE_TM_ERROR_TYPE_UNSPECIFIED,
1501                                                 NULL,
1502                                                 rte_strerror(EINVAL));
1503                         }
1504                 } else if (n->node_state ==
1505                                 IPN3KE_TM_NODE_STATE_CONFIGURED_DEL) {
1506                         if (n->level != IPN3KE_TM_NODE_LEVEL_COS ||
1507                                 n->n_children != 0) {
1508                                 return -rte_tm_error_set(error,
1509                                                 EINVAL,
1510                                                 RTE_TM_ERROR_TYPE_UNSPECIFIED,
1511                                                 NULL,
1512                                                 rte_strerror(EINVAL));
1513                         } else {
1514                                 return -rte_tm_error_set(error,
1515                                                 EINVAL,
1516                                                 RTE_TM_ERROR_TYPE_UNSPECIFIED,
1517                                                 NULL,
1518                                                 rte_strerror(EINVAL));
1519                         }
1520                 }
1521         }
1522
1523         nl = &tm->h.vt_commit_node_list;
1524         TAILQ_FOREACH(n, nl, node) {
1525                 parent_node = n->parent_node;
1526                 if (n->node_state == IPN3KE_TM_NODE_STATE_CONFIGURED_ADD) {
1527                         if (n->parent_node_id == RTE_TM_NODE_ID_NULL ||
1528                                 n->level != IPN3KE_TM_NODE_LEVEL_VT ||
1529                                 n->tm_id != tm_id ||
1530                                 parent_node == NULL ||
1531                                 (parent_node &&
1532                                         parent_node->node_state ==
1533                                         IPN3KE_TM_NODE_STATE_CONFIGURED_DEL) ||
1534                                 (parent_node &&
1535                                         parent_node->node_state ==
1536                                                 IPN3KE_TM_NODE_STATE_IDLE) ||
1537                                 n->shaper_profile.valid == 0) {
1538                                 return -rte_tm_error_set(error,
1539                                                 EINVAL,
1540                                                 RTE_TM_ERROR_TYPE_UNSPECIFIED,
1541                                                 NULL,
1542                                                 rte_strerror(EINVAL));
1543                         }
1544                 } else if (n->node_state == IPN3KE_TM_NODE_STATE_CONFIGURED_DEL)
1545                         return -rte_tm_error_set(error,
1546                                                 EINVAL,
1547                                                 RTE_TM_ERROR_TYPE_UNSPECIFIED,
1548                                                 NULL,
1549                                                 rte_strerror(EINVAL));
1550         }
1551
1552         n = tm->h.port_commit_node;
1553         if (n &&
1554                 (n->parent_node_id != RTE_TM_NODE_ID_NULL ||
1555                 n->level != IPN3KE_TM_NODE_LEVEL_PORT ||
1556                 n->tm_id != tm_id ||
1557                 n->parent_node != NULL ||
1558                 n->shaper_profile.valid == 0)) {
1559                 return -rte_tm_error_set(error,
1560                                         EINVAL,
1561                                         RTE_TM_ERROR_TYPE_UNSPECIFIED,
1562                                         NULL,
1563                                         rte_strerror(EINVAL));
1564         }
1565
1566         return 0;
1567 }
1568
1569 static int
1570 ipn3ke_hw_tm_node_wr(struct ipn3ke_hw *hw,
1571         struct ipn3ke_tm_node *n,
1572         struct ipn3ke_tm_node *parent_node)
1573 {
1574         uint32_t level;
1575
1576         level = n->level;
1577
1578         switch (level) {
1579         case IPN3KE_TM_NODE_LEVEL_PORT:
1580                 /**
1581                  * Configure Type
1582                  */
1583                 IPN3KE_MASK_WRITE_REG(hw,
1584                                 IPN3KE_QOS_TYPE_L3_X,
1585                                 n->node_index,
1586                                 n->priority,
1587                                 IPN3KE_QOS_TYPE_MASK);
1588
1589                 /**
1590                  * Configure Sch_wt
1591                  */
1592                 IPN3KE_MASK_WRITE_REG(hw,
1593                                 IPN3KE_QOS_SCH_WT_L3_X,
1594                                 n->node_index,
1595                                 n->weight,
1596                                 IPN3KE_QOS_SCH_WT_MASK);
1597
1598                 /**
1599                  * Configure Shap_wt
1600                  */
1601                 if (n->shaper_profile.valid)
1602                         IPN3KE_MASK_WRITE_REG(hw,
1603                                         IPN3KE_QOS_SHAP_WT_L3_X,
1604                                         n->node_index,
1605                                         ((n->shaper_profile.e << 10) |
1606                                                 n->shaper_profile.m),
1607                                         IPN3KE_QOS_SHAP_WT_MASK);
1608
1609                 break;
1610         case IPN3KE_TM_NODE_LEVEL_VT:
1611                 /**
1612                  * Configure Type
1613                  */
1614                 IPN3KE_MASK_WRITE_REG(hw,
1615                                 IPN3KE_QOS_TYPE_L2_X,
1616                                 n->node_index,
1617                                 n->priority,
1618                                 IPN3KE_QOS_TYPE_MASK);
1619
1620                 /**
1621                  * Configure Sch_wt
1622                  */
1623                 IPN3KE_MASK_WRITE_REG(hw,
1624                                 IPN3KE_QOS_SCH_WT_L2_X,
1625                                 n->node_index,
1626                                 n->weight,
1627                                 IPN3KE_QOS_SCH_WT_MASK);
1628
1629                 /**
1630                  * Configure Shap_wt
1631                  */
1632                 if (n->shaper_profile.valid)
1633                         IPN3KE_MASK_WRITE_REG(hw,
1634                                         IPN3KE_QOS_SHAP_WT_L2_X,
1635                                         n->node_index,
1636                                         ((n->shaper_profile.e << 10) |
1637                                                 n->shaper_profile.m),
1638                                         IPN3KE_QOS_SHAP_WT_MASK);
1639
1640                 /**
1641                  * Configure Map
1642                  */
1643                 if (parent_node)
1644                         IPN3KE_MASK_WRITE_REG(hw,
1645                                         IPN3KE_QOS_MAP_L2_X,
1646                                         n->node_index,
1647                                         parent_node->node_index,
1648                                         IPN3KE_QOS_MAP_L2_MASK);
1649
1650                 break;
1651         case IPN3KE_TM_NODE_LEVEL_COS:
1652                 /**
1653                  * Configure Tail Drop mapping
1654                  */
1655                 if (n->tdrop_profile && n->tdrop_profile->valid) {
1656                         IPN3KE_MASK_WRITE_REG(hw,
1657                                         IPN3KE_CCB_QPROFILE_Q,
1658                                         n->node_index,
1659                                         n->tdrop_profile->tdrop_profile_id,
1660                                         IPN3KE_CCB_QPROFILE_MASK);
1661                 }
1662
1663                 /**
1664                  * Configure Type
1665                  */
1666                 IPN3KE_MASK_WRITE_REG(hw,
1667                                 IPN3KE_QOS_TYPE_L1_X,
1668                                 n->node_index,
1669                                 n->priority,
1670                                 IPN3KE_QOS_TYPE_MASK);
1671
1672                 /**
1673                  * Configure Sch_wt
1674                  */
1675                 IPN3KE_MASK_WRITE_REG(hw,
1676                                 IPN3KE_QOS_SCH_WT_L1_X,
1677                                 n->node_index,
1678                                 n->weight,
1679                                 IPN3KE_QOS_SCH_WT_MASK);
1680
1681                 /**
1682                  * Configure Shap_wt
1683                  */
1684                 if (n->shaper_profile.valid)
1685                         IPN3KE_MASK_WRITE_REG(hw,
1686                                         IPN3KE_QOS_SHAP_WT_L1_X,
1687                                         n->node_index,
1688                                         ((n->shaper_profile.e << 10) |
1689                                                 n->shaper_profile.m),
1690                                         IPN3KE_QOS_SHAP_WT_MASK);
1691
1692                 /**
1693                  * Configure COS queue to port
1694                  */
1695                 while (IPN3KE_MASK_READ_REG(hw,
1696                                         IPN3KE_QM_UID_CONFIG_CTRL,
1697                                         0,
1698                                         0x80000000))
1699                         ;
1700
1701                 if (parent_node && parent_node->parent_node)
1702                         IPN3KE_MASK_WRITE_REG(hw,
1703                                 IPN3KE_QM_UID_CONFIG_DATA,
1704                                 0,
1705                                 (1 << 8 | parent_node->parent_node->node_index),
1706                                 0x1FF);
1707
1708                 IPN3KE_MASK_WRITE_REG(hw,
1709                                 IPN3KE_QM_UID_CONFIG_CTRL,
1710                                 0,
1711                                 n->node_index,
1712                                 0xFFFFF);
1713
1714                 while (IPN3KE_MASK_READ_REG(hw,
1715                                         IPN3KE_QM_UID_CONFIG_CTRL,
1716                                         0,
1717                                         0x80000000))
1718                         ;
1719
1720                 /**
1721                  * Configure Map
1722                  */
1723                 if (parent_node)
1724                         IPN3KE_MASK_WRITE_REG(hw,
1725                                         IPN3KE_QOS_MAP_L1_X,
1726                                         n->node_index,
1727                                         parent_node->node_index,
1728                                         IPN3KE_QOS_MAP_L1_MASK);
1729
1730                 break;
1731         default:
1732                 return -1;
1733         }
1734
1735         return 0;
1736 }
1737
1738 static int
1739 ipn3ke_tm_hierarchy_hw_commit(struct rte_eth_dev *dev,
1740                                         struct rte_tm_error *error)
1741 {
1742         struct ipn3ke_hw *hw = IPN3KE_DEV_PRIVATE_TO_HW(dev);
1743         struct ipn3ke_tm_internals *tm = IPN3KE_DEV_PRIVATE_TO_TM(dev);
1744         struct ipn3ke_tm_node_list *nl;
1745         struct ipn3ke_tm_node *n, *nn, *parent_node;
1746
1747         n = tm->h.port_commit_node;
1748         if (n) {
1749                 if (n->node_state == IPN3KE_TM_NODE_STATE_CONFIGURED_ADD) {
1750                         tm->h.port_commit_node = NULL;
1751
1752                         n->node_state = IPN3KE_TM_NODE_STATE_COMMITTED;
1753                 } else if (n->node_state ==
1754                                         IPN3KE_TM_NODE_STATE_CONFIGURED_DEL) {
1755                         tm->h.port_commit_node = NULL;
1756
1757                         n->node_state = IPN3KE_TM_NODE_STATE_IDLE;
1758                         n->priority = IPN3KE_TM_NODE_PRIORITY_NORMAL0;
1759                         n->weight = 0;
1760                         n->tm_id = RTE_TM_NODE_ID_NULL;
1761                 } else {
1762                         return -rte_tm_error_set(error,
1763                                                 EINVAL,
1764                                                 RTE_TM_ERROR_TYPE_UNSPECIFIED,
1765                                                 NULL,
1766                                                 rte_strerror(EINVAL));
1767                 }
1768                 parent_node = n->parent_node;
1769                 ipn3ke_hw_tm_node_wr(hw, n, parent_node);
1770         }
1771
1772         nl = &tm->h.vt_commit_node_list;
1773         for (n = TAILQ_FIRST(nl); n != NULL; n = nn) {
1774                 nn = TAILQ_NEXT(n, node);
1775                 if (n->node_state == IPN3KE_TM_NODE_STATE_CONFIGURED_ADD) {
1776                         n->node_state = IPN3KE_TM_NODE_STATE_COMMITTED;
1777                         parent_node = n->parent_node;
1778                         TAILQ_REMOVE(nl, n, node);
1779                         TAILQ_INSERT_TAIL(&parent_node->children_node_list,
1780                                                 n, node);
1781                 } else if (n->node_state ==
1782                                         IPN3KE_TM_NODE_STATE_CONFIGURED_DEL) {
1783                         parent_node = n->parent_node;
1784                         TAILQ_REMOVE(nl, n, node);
1785
1786                         n->node_state = IPN3KE_TM_NODE_STATE_IDLE;
1787                         n->parent_node_id = RTE_TM_NODE_ID_NULL;
1788                         n->priority = IPN3KE_TM_NODE_PRIORITY_NORMAL0;
1789                         n->weight = 0;
1790                         n->tm_id = RTE_TM_NODE_ID_NULL;
1791                         n->parent_node = NULL;
1792                 } else {
1793                         return -rte_tm_error_set(error,
1794                                                 EINVAL,
1795                                                 RTE_TM_ERROR_TYPE_UNSPECIFIED,
1796                                                 NULL,
1797                                                 rte_strerror(EINVAL));
1798                 }
1799                 ipn3ke_hw_tm_node_wr(hw, n, parent_node);
1800         }
1801
1802         nl = &tm->h.cos_commit_node_list;
1803         for (n = TAILQ_FIRST(nl); n != NULL; n = nn) {
1804                 nn = TAILQ_NEXT(n, node);
1805                 if (n->node_state == IPN3KE_TM_NODE_STATE_CONFIGURED_ADD) {
1806                         n->node_state = IPN3KE_TM_NODE_STATE_COMMITTED;
1807                         parent_node = n->parent_node;
1808                         TAILQ_REMOVE(nl, n, node);
1809                         TAILQ_INSERT_TAIL(&parent_node->children_node_list,
1810                                         n, node);
1811                 } else if (n->node_state ==
1812                                         IPN3KE_TM_NODE_STATE_CONFIGURED_DEL) {
1813                         n->node_state = IPN3KE_TM_NODE_STATE_IDLE;
1814                         parent_node = n->parent_node;
1815                         TAILQ_REMOVE(nl, n, node);
1816
1817                         n->node_state = IPN3KE_TM_NODE_STATE_IDLE;
1818                         n->parent_node_id = RTE_TM_NODE_ID_NULL;
1819                         n->priority = IPN3KE_TM_NODE_PRIORITY_NORMAL0;
1820                         n->weight = 0;
1821                         n->tm_id = RTE_TM_NODE_ID_NULL;
1822                         n->parent_node = NULL;
1823
1824                         if (n->tdrop_profile)
1825                                 n->tdrop_profile->n_users--;
1826                 } else {
1827                         return -rte_tm_error_set(error,
1828                                                 EINVAL,
1829                                                 RTE_TM_ERROR_TYPE_UNSPECIFIED,
1830                                                 NULL,
1831                                                 rte_strerror(EINVAL));
1832                 }
1833                 ipn3ke_hw_tm_node_wr(hw, n, parent_node);
1834         }
1835
1836         return 0;
1837 }
1838
1839 static int
1840 ipn3ke_tm_hierarchy_commit_clear(struct rte_eth_dev *dev)
1841 {
1842         struct ipn3ke_tm_internals *tm = IPN3KE_DEV_PRIVATE_TO_TM(dev);
1843         struct ipn3ke_tm_node_list *nl;
1844         struct ipn3ke_tm_node *n;
1845         struct ipn3ke_tm_node *nn;
1846
1847         n = tm->h.port_commit_node;
1848         if (n) {
1849                 n->node_state = IPN3KE_TM_NODE_STATE_IDLE;
1850                 n->priority = IPN3KE_TM_NODE_PRIORITY_NORMAL0;
1851                 n->weight = 0;
1852                 n->tm_id = RTE_TM_NODE_ID_NULL;
1853                 n->n_children = 0;
1854
1855                 tm->h.port_commit_node = NULL;
1856         }
1857
1858         nl = &tm->h.vt_commit_node_list;
1859         for (n = TAILQ_FIRST(nl); n != NULL; n = nn) {
1860                 nn = TAILQ_NEXT(n, node);
1861
1862                 n->node_state = IPN3KE_TM_NODE_STATE_IDLE;
1863                 n->parent_node_id = RTE_TM_NODE_ID_NULL;
1864                 n->priority = IPN3KE_TM_NODE_PRIORITY_NORMAL0;
1865                 n->weight = 0;
1866                 n->tm_id = RTE_TM_NODE_ID_NULL;
1867                 n->parent_node = NULL;
1868                 n->n_children = 0;
1869                 tm->h.n_vt_nodes--;
1870
1871                 TAILQ_REMOVE(nl, n, node);
1872         }
1873
1874         nl = &tm->h.cos_commit_node_list;
1875         for (n = TAILQ_FIRST(nl); n != NULL; n = nn) {
1876                 nn = TAILQ_NEXT(n, node);
1877
1878                 n->node_state = IPN3KE_TM_NODE_STATE_IDLE;
1879                 n->parent_node_id = RTE_TM_NODE_ID_NULL;
1880                 n->priority = IPN3KE_TM_NODE_PRIORITY_NORMAL0;
1881                 n->weight = 0;
1882                 n->tm_id = RTE_TM_NODE_ID_NULL;
1883                 n->parent_node = NULL;
1884                 tm->h.n_cos_nodes--;
1885
1886                 TAILQ_REMOVE(nl, n, node);
1887         }
1888
1889         return 0;
1890 }
1891
1892 static void
1893 ipn3ke_tm_show(struct rte_eth_dev *dev)
1894 {
1895         struct ipn3ke_tm_internals *tm = IPN3KE_DEV_PRIVATE_TO_TM(dev);
1896         uint32_t tm_id;
1897         struct ipn3ke_tm_node_list *vt_nl, *cos_nl;
1898         struct ipn3ke_tm_node *port_n, *vt_n, *cos_n;
1899         const char *str_state[IPN3KE_TM_NODE_STATE_MAX] = {"Idle",
1900                                                 "CfgAdd",
1901                                                 "CfgDel",
1902                                                 "Committed"};
1903
1904         tm_id = tm->tm_id;
1905
1906         IPN3KE_AFU_PMD_DEBUG("***HQoS Tree(%d)***\n", tm_id);
1907
1908         port_n = tm->h.port_node;
1909         IPN3KE_AFU_PMD_DEBUG("Port: (%d|%s)\n", port_n->node_index,
1910                                 str_state[port_n->node_state]);
1911
1912         vt_nl = &tm->h.port_node->children_node_list;
1913         TAILQ_FOREACH(vt_n, vt_nl, node) {
1914                 cos_nl = &vt_n->children_node_list;
1915                 IPN3KE_AFU_PMD_DEBUG("    VT%d: ", vt_n->node_index);
1916                 TAILQ_FOREACH(cos_n, cos_nl, node) {
1917                         if (cos_n->parent_node_id !=
1918                                 (vt_n->node_index + IPN3KE_TM_NODE_LEVEL_MOD))
1919                                 IPN3KE_AFU_PMD_ERR("(%d|%s), ",
1920                                         cos_n->node_index,
1921                                         str_state[cos_n->node_state]);
1922                 }
1923                 IPN3KE_AFU_PMD_DEBUG("\n");
1924         }
1925 }
1926
1927 static void
1928 ipn3ke_tm_show_commmit(struct rte_eth_dev *dev)
1929 {
1930         struct ipn3ke_tm_internals *tm = IPN3KE_DEV_PRIVATE_TO_TM(dev);
1931         uint32_t tm_id;
1932         struct ipn3ke_tm_node_list *nl;
1933         struct ipn3ke_tm_node *n;
1934         const char *str_state[IPN3KE_TM_NODE_STATE_MAX] = {"Idle",
1935                                                 "CfgAdd",
1936                                                 "CfgDel",
1937                                                 "Committed"};
1938
1939         tm_id = tm->tm_id;
1940
1941         IPN3KE_AFU_PMD_DEBUG("***Commit Tree(%d)***\n", tm_id);
1942         n = tm->h.port_commit_node;
1943         IPN3KE_AFU_PMD_DEBUG("Port: ");
1944         if (n)
1945                 IPN3KE_AFU_PMD_DEBUG("(%d|%s)",
1946                         n->node_index,
1947                         str_state[n->node_state]);
1948         IPN3KE_AFU_PMD_DEBUG("\n");
1949
1950         nl = &tm->h.vt_commit_node_list;
1951         IPN3KE_AFU_PMD_DEBUG("VT  : ");
1952         TAILQ_FOREACH(n, nl, node) {
1953                 IPN3KE_AFU_PMD_DEBUG("(%d|%s), ",
1954                                 n->node_index,
1955                                 str_state[n->node_state]);
1956         }
1957         IPN3KE_AFU_PMD_DEBUG("\n");
1958
1959         nl = &tm->h.cos_commit_node_list;
1960         IPN3KE_AFU_PMD_DEBUG("COS : ");
1961         TAILQ_FOREACH(n, nl, node) {
1962                 IPN3KE_AFU_PMD_DEBUG("(%d|%s), ",
1963                                 n->node_index,
1964                                 str_state[n->node_state]);
1965         }
1966         IPN3KE_AFU_PMD_DEBUG("\n");
1967 }
1968
1969 /* Traffic manager hierarchy commit */
1970 static int
1971 ipn3ke_tm_hierarchy_commit(struct rte_eth_dev *dev,
1972         int clear_on_fail, struct rte_tm_error *error)
1973 {
1974         struct ipn3ke_tm_internals *tm = IPN3KE_DEV_PRIVATE_TO_TM(dev);
1975         int status;
1976
1977         /* Checks */
1978         if (tm->hierarchy_frozen)
1979                 return -rte_tm_error_set(error,
1980                                         EBUSY,
1981                                         RTE_TM_ERROR_TYPE_UNSPECIFIED,
1982                                         NULL,
1983                                         rte_strerror(EBUSY));
1984
1985         ipn3ke_tm_show_commmit(dev);
1986
1987         status = ipn3ke_tm_hierarchy_commit_check(dev, error);
1988         if (status) {
1989                 if (clear_on_fail)
1990                         ipn3ke_tm_hierarchy_commit_clear(dev);
1991                 return status;
1992         }
1993
1994         ipn3ke_tm_hierarchy_hw_commit(dev, error);
1995         ipn3ke_tm_show(dev);
1996
1997         return 0;
1998 }
1999
2000 const struct rte_tm_ops ipn3ke_tm_ops = {
2001         .node_type_get = ipn3ke_pmd_tm_node_type_get,
2002         .capabilities_get = ipn3ke_tm_capabilities_get,
2003         .level_capabilities_get = ipn3ke_tm_level_capabilities_get,
2004         .node_capabilities_get = ipn3ke_tm_node_capabilities_get,
2005
2006         .wred_profile_add = ipn3ke_tm_tdrop_profile_add,
2007         .wred_profile_delete = ipn3ke_tm_tdrop_profile_delete,
2008         .shared_wred_context_add_update = NULL,
2009         .shared_wred_context_delete = NULL,
2010
2011         .shaper_profile_add = ipn3ke_tm_shaper_profile_add,
2012         .shaper_profile_delete = ipn3ke_tm_shaper_profile_delete,
2013         .shared_shaper_add_update = NULL,
2014         .shared_shaper_delete = NULL,
2015
2016         .node_add = ipn3ke_tm_node_add,
2017         .node_delete = ipn3ke_pmd_tm_node_delete,
2018         .node_suspend = NULL,
2019         .node_resume = NULL,
2020         .hierarchy_commit = ipn3ke_tm_hierarchy_commit,
2021
2022         .node_parent_update = NULL,
2023         .node_shaper_update = NULL,
2024         .node_shared_shaper_update = NULL,
2025         .node_stats_update = NULL,
2026         .node_wfq_weight_mode_update = NULL,
2027         .node_cman_update = NULL,
2028         .node_wred_context_update = NULL,
2029         .node_shared_wred_context_update = NULL,
2030
2031         .node_stats_read = NULL,
2032 };
2033
2034 int
2035 ipn3ke_tm_ops_get(struct rte_eth_dev *ethdev,
2036                 void *arg)
2037 {
2038         struct ipn3ke_hw *hw = IPN3KE_DEV_PRIVATE_TO_HW(ethdev);
2039         struct ipn3ke_rpst *rpst = IPN3KE_DEV_PRIVATE_TO_RPST(ethdev);
2040         struct rte_eth_dev *i40e_pf_eth;
2041         const struct rte_tm_ops *ops;
2042
2043         if (!arg)
2044                 return -EINVAL;
2045
2046         if (hw->acc_tm) {
2047                 *(const void **)arg = &ipn3ke_tm_ops;
2048         } else if (rpst->i40e_pf_eth) {
2049                 i40e_pf_eth = rpst->i40e_pf_eth;
2050                 if (i40e_pf_eth->dev_ops->tm_ops_get == NULL ||
2051                         i40e_pf_eth->dev_ops->tm_ops_get(i40e_pf_eth,
2052                         &ops) != 0 ||
2053                         ops == NULL) {
2054                         return -EINVAL;
2055                 }
2056                 *(const void **)arg = ops;
2057         } else {
2058                 return -EINVAL;
2059         }
2060
2061         return 0;
2062 }