Lines Matching defs:node
35 * ice_sched_add_root_node - Insert the Tx scheduler root node in SW DB
39 * This function inserts the root node of the scheduling tree topology
71 * ice_sched_find_node_by_teid - Find the Tx scheduler node in SW DB
73 * @teid: node TEID to search
75 * This function searches for a node matching the TEID in the scheduling tree
93 /* The node has no children or is at the max layer */
171 * ice_sched_add_node - Insert the Tx scheduler node in SW DB
173 * @layer: Scheduler layer of the node
177 * This function inserts a scheduler node to the SW DB.
186 struct ice_sched_node *node;
195 /* A valid parent node should be there */
204 /* query the current node information from FW before adding it
212 node = prealloc_node;
214 node = (struct ice_sched_node *)ice_malloc(hw, sizeof(*node));
215 if (!node)
218 node->children = (struct ice_sched_node **)
220 sizeof(*node->children));
221 if (!node->children) {
222 ice_free(hw, node);
227 node->in_use = true;
228 node->parent = parent;
229 node->tx_sched_layer = layer;
230 parent->children[parent->num_children++] = node;
231 node->info = elem;
259 * @parent: pointer to the parent node
261 * @node_teids: array of node teids to be deleted
287 ice_debug(hw, ICE_DBG_SCHED, "remove node failed FW error %d\n",
295 * ice_sched_get_first_node - get the first node of the given layer
297 * @parent: pointer the base node of the subtree
300 * This function retrieves the first node of the given layer from the subtree
310 * ice_sched_get_tc_node - get pointer to TC node
314 * This function returns the TC node pointer
329 * ice_free_sched_node - Free a Tx scheduler node from SW DB
331 * @node: pointer to the ice_sched_node struct
333 * This function frees up a node from SW DB as well as from HW
337 void ice_free_sched_node(struct ice_port_info *pi, struct ice_sched_node *node)
343 /* Free the children before freeing up the parent node
347 while (node->num_children)
348 ice_free_sched_node(pi, node->children[0]);
351 if (node->tx_sched_layer >= hw->sw_entry_point_layer &&
352 node->info.data.elem_type != ICE_AQC_ELEM_TYPE_TC &&
353 node->info.data.elem_type != ICE_AQC_ELEM_TYPE_ROOT_PORT &&
354 node->info.data.elem_type != ICE_AQC_ELEM_TYPE_LEAF) {
355 u32 teid = LE32_TO_CPU(node->info.node_teid);
357 ice_sched_remove_elems(hw, node->parent, 1, &teid);
359 parent = node->parent;
366 if (parent->children[i] == node) {
374 p = ice_sched_get_first_node(pi, node, node->tx_sched_layer);
376 if (p->sibling == node) {
377 p->sibling = node->sibling;
384 if (pi->sib_head[node->tc_num][node->tx_sched_layer] == node)
385 pi->sib_head[node->tc_num][node->tx_sched_layer] =
386 node->sibling;
390 if (node->children)
391 ice_free(hw, node->children);
392 ice_free(hw, node);
552 * @node_teids: array of node teids to be suspended or resumed
947 * ice_aq_cfg_l2_node_cgd - configures L2 node to CGD mapping
975 * @tc_node: pointer to the branch node
976 * @parent: pointer to the parent node
980 * @first_node_teid: if new nodes are added then return the TEID of first node
1026 ice_debug(hw, ICE_DBG_SCHED, "add node failed FW Error %d\n",
1056 /* add it to previous node sibling pointer */
1080 * @tc_node: pointer to TC node
1081 * @parent: pointer to parent node
1084 * @first_node_teid: pointer to the first node TEID
1106 /* max children per node per layer */
1111 /* Fail if the parent is a TC node */
1124 * @tc_node: pointer to TC node
1125 * @parent: pointer to parent node
1128 * @first_node_teid: pointer to the first node TEID
1176 /* Don't modify the first node TEID memory if the
1177 * first node was added already in the above call.
1243 * ice_rm_dflt_leaf_node - remove the default leaf node in the tree
1246 * This function removes the leaf node that was created by the FW
1251 struct ice_sched_node *node;
1253 node = pi->root;
1254 while (node) {
1255 if (!node->num_children)
1257 node = node->children[0];
1259 if (node && node->info.data.elem_type == ICE_AQC_ELEM_TYPE_LEAF) {
1260 u32 teid = LE32_TO_CPU(node->info.node_teid);
1263 /* remove the default leaf node */
1264 status = ice_sched_remove_elems(pi->hw, node->parent, 1, &teid);
1266 ice_free_sched_node(pi, node);
1279 struct ice_sched_node *node;
1284 node = pi->root;
1285 while (node) {
1286 if (node->tx_sched_layer >= pi->hw->sw_entry_point_layer &&
1287 node->info.data.elem_type != ICE_AQC_ELEM_TYPE_TC &&
1288 node->info.data.elem_type != ICE_AQC_ELEM_TYPE_ROOT_PORT) {
1289 ice_free_sched_node(pi, node);
1293 if (!node->num_children)
1295 node = node->children[0];
1351 /* If the last node is a leaf node then the index of the queue group
1362 /* Insert the Tx Sched root node */
1407 * @teid: Scheduler node TEID
1414 struct ice_sched_node *node;
1419 /* Find the node starting from root */
1421 node = ice_sched_find_node_by_teid(pi->root, teid);
1424 if (!node)
1427 return node;
1463 * of the below layer node.
1464 * layer 1 node max children will be layer 2 max sibling group size
1465 * layer 2 node max children will be layer 3 max sibling group size
1467 * qgroup layer 7. Leaf node has no children.
1526 * ice_sched_find_node_in_subtree - Find node in part of base node subtree
1528 * @base: pointer to the base node
1529 * @node: pointer to the node to search
1531 * This function checks whether a given node is part of the base node
1536 struct ice_sched_node *node)
1543 if (node == child)
1546 if (child->tx_sched_layer > node->tx_sched_layer)
1552 if (ice_sched_find_node_in_subtree(hw, child, node))
1559 * ice_sched_get_free_qgrp - Scan all queue group siblings and find a free node
1562 * @qgrp_node: first queue group node identified for scanning
1565 * This function retrieves a free LAN or RDMA queue group node by scanning
1583 /* scan all queue groups until find a node which has less than the
1589 /* make sure the qgroup node is part of the VSI subtree */
1593 /* replace the new min queue group node */
1606 * ice_sched_get_free_qparent - Get a free LAN or RDMA queue group node
1612 * This function retrieves a free LAN or RDMA queue group node
1641 /* get the first queue group node from VSI sub-tree */
1644 /* make sure the qgroup node is part of the VSI subtree */
1657 * ice_sched_get_vsi_node - Get a VSI node based on VSI ID
1659 * @tc_node: pointer to the TC node
1662 * This function retrieves a VSI node for a given VSI ID from a given
1669 struct ice_sched_node *node;
1673 node = ice_sched_get_first_node(pi, tc_node, vsi_layer);
1676 while (node) {
1677 if (node->vsi_handle == vsi_handle)
1678 return node;
1679 node = node->sibling;
1682 return node;
1686 * ice_sched_get_agg_node - Get an aggregator node based on aggregator ID
1688 * @tc_node: pointer to the TC node
1691 * This function retrieves an aggregator node for a given aggregator ID from
1698 struct ice_sched_node *node;
1705 node = ice_sched_get_first_node(pi, tc_node, agg_layer);
1708 while (node) {
1709 if (node->agg_id == agg_id)
1710 return node;
1711 node = node->sibling;
1714 return node;
1718 * ice_sched_check_node - Compare node parameters between SW DB and HW DB
1720 * @node: pointer to the ice_sched_node struct
1722 * This function queries and compares the HW element with SW DB node parameters
1724 static bool ice_sched_check_node(struct ice_hw *hw, struct ice_sched_node *node)
1730 node_teid = LE32_TO_CPU(node->info.node_teid);
1735 if (memcmp(&buf, &node->info, sizeof(buf))) {
1767 /* need at least one node */
1776 * @tc_node: pointer to the TC node
1778 * @owner: node owner (LAN or RDMA)
1788 struct ice_sched_node *parent, *node;
1810 /* The newly added node can be a new parent for the next
1816 node = parent;
1817 while (node) {
1818 node->owner = owner;
1819 node = node->sibling;
1832 * @tc_node: pointer to TC node
1843 struct ice_sched_node *node;
1850 * need at least one node for VSI
1858 node = ice_sched_get_first_node(pi, tc_node, (u8)i);
1860 while (node) {
1861 if (node->num_children <
1864 node = node->sibling;
1867 /* tree has one intermediate node to add this new VSI.
1871 if (node)
1882 * @tc_node: pointer to TC node
1911 /* The newly added node can be a new parent for the next
2141 * ice_sched_is_leaf_node_present - check for a leaf node in the sub-tree
2142 * @node: pointer to the sub-tree node
2144 * This function checks for a leaf node presence in a given sub-tree node.
2146 static bool ice_sched_is_leaf_node_present(struct ice_sched_node *node)
2150 for (i = 0; i < node->num_children; i++)
2151 if (ice_sched_is_leaf_node_present(node->children[i]))
2153 /* check for a leaf node */
2154 return (node->info.data.elem_type == ICE_AQC_ELEM_TYPE_LEAF);
2203 * children will be updated after node removal
2259 * @node: pointer to the ice_sched_node struct
2264 bool ice_sched_is_tree_balanced(struct ice_hw *hw, struct ice_sched_node *node)
2268 /* start from the leaf node */
2269 for (i = 0; i < node->num_children; i++)
2270 /* Fail if node doesn't match with the SW DB
2274 if (!ice_sched_is_tree_balanced(hw, node->children[i]))
2277 return ice_sched_check_node(hw, node);
2281 * ice_aq_query_node_to_root - retrieve the tree topology for a given node TEID
2283 * @node_teid: node TEID
2289 * node TEID to the root node.
2327 * ice_sched_get_free_vsi_parent - Find a free parent node in aggregator subtree
2329 * @node: pointer to a child node
2333 * node
2336 ice_sched_get_free_vsi_parent(struct ice_hw *hw, struct ice_sched_node *node,
2339 u8 l = node->tx_sched_layer;
2346 return (node->num_children < hw->max_children[l]) ? node : NULL;
2349 * intermediate node has space to add a new node then clear the count
2351 if (node->num_children < hw->max_children[l])
2357 for (i = 0; i < node->num_children; i++) {
2360 parent = ice_sched_get_free_vsi_parent(hw, node->children[i],
2371 * @new_parent: pointer to a new parent node
2372 * @node: pointer to a child node
2379 struct ice_sched_node *node)
2384 old_parent = node->parent;
2388 if (old_parent->children[i] == node) {
2396 /* now move the node to a new parent */
2397 new_parent->children[new_parent->num_children++] = node;
2398 node->parent = new_parent;
2399 node->info.parent_teid = new_parent->info.node_teid;
2405 * @parent: pointer to parent node
2407 * @list: pointer to child node teids
2416 struct ice_sched_node *node;
2438 node = ice_sched_find_node_by_teid(pi->root, list[i]);
2439 if (!node) {
2444 buf->hdr.src_parent_teid = node->info.parent_teid;
2446 buf->teid[0] = node->info.node_teid;
2456 ice_sched_update_parent(parent, node);
2465 * ice_sched_move_vsi_to_agg - move VSI to aggregator node
2471 * This function moves a VSI to an aggregator node or its subtree.
2504 /* set intermediate node count to 1 between aggregator and VSI layers */
2508 /* Check if the aggregator subtree has any free node to add the VSI */
2527 /* The newly added node can be a new parent for the next
2591 * @node: node pointer
2596 ice_sched_is_agg_inuse(struct ice_port_info *pi, struct ice_sched_node *node)
2601 if (node->tx_sched_layer < vsil - 1) {
2602 for (i = 0; i < node->num_children; i++)
2603 if (ice_sched_is_agg_inuse(pi, node->children[i]))
2607 return node->num_children ? true : false;
2612 * ice_sched_rm_agg_cfg - remove the aggregator node
2617 * This function removes the aggregator node and intermediate nodes if any
2634 /* Can't remove the aggregator node if it has children */
2638 /* need to remove the whole subtree if aggregator node is the
2682 /* Delete aggregator node(s) */
2716 * ice_sched_add_agg_cfg - create an aggregator node
2721 * This function creates an aggregator node and intermediate nodes if required
2740 /* Does Agg node already exist ? */
2746 /* need one node in Agg layer */
2751 * intermediate node on those layers
2768 /* add the aggregator node */
2781 /* The newly added node can be a new parent for the next
2787 /* register aggregator ID with the aggregator node */
2799 * ice_sched_cfg_agg - configure aggregator node
2805 * It registers a unique aggregator node into scheduler services. It
2808 * or aggregator group. It then creates the aggregator node(s) for requested
2809 * TC(s) or removes an existing aggregator node including its configuration
2841 /* Create aggregator node(s) for requested TC(s) */
2851 /* Check if aggregator node for TC already exists */
2855 /* Create new aggregator node for TC */
2860 /* Save aggregator node's TC information */
2868 * ice_cfg_agg - config aggregator node
2874 * This function configures aggregator node(s).
2975 * This function moves VSI to a new or default aggregator node. If VSI is
2976 * already associated to the aggregator node then no operation is performed on
3021 /* Move VSI node to new aggregator node for requested TC(s) */
3069 * @node: pointer to node
3070 * @info: node info to update
3072 * Update the HW DB, and local SW DB of node. Update the scheduling
3073 * parameters of node from argument info data buffer (Info->data buf) and
3078 ice_sched_update_elem(struct ice_hw *hw, struct ice_sched_node *node,
3088 if (node->info.data.elem_type == ICE_AQC_ELEM_TYPE_TC)
3098 /* Configure element node */
3109 node->info.data = info->data;
3114 * ice_sched_cfg_node_bw_alloc - configure node BW weight/alloc params
3116 * @node: sched node to configure
3120 * This function configures node element's BW allocation.
3123 ice_sched_cfg_node_bw_alloc(struct ice_hw *hw, struct ice_sched_node *node,
3130 buf = node->info;
3143 status = ice_sched_update_elem(hw, node, &buf);
3154 * Move or associate VSI to a new or default aggregator node.
3254 * ice_sched_save_vsi_bw_alloc - save VSI node's BW alloc information
3261 * Save BW alloc information of VSI type node for post replay use.
3347 * ice_sched_save_vsi_bw - save VSI node's BW information
3354 * Save BW information of VSI type node for post replay use.
3400 * ice_sched_save_vsi_prio - save VSI node's priority information
3406 * Save priority information of VSI type node for post replay use.
3426 * ice_sched_save_agg_bw_alloc - save aggregator node's BW alloc information
3428 * @agg_id: node aggregator ID
3433 * Save BW alloc information of AGG type node for post replay use.
3460 * ice_sched_save_agg_bw - save aggregator node's BW information
3462 * @agg_id: node aggregator ID
3467 * Save BW information of AGG type node for post replay use.
3504 * This function configures BW limit of VSI scheduling node based on TC
3531 * This function configures default BW limit of VSI scheduling node based on TC
3561 * This function applies BW limit to aggregator scheduling node based on TC
3587 * This function applies default BW limit to aggregator scheduling node based
3718 * ice_cfg_vsi_q_priority - config VSI queue priority of node
3724 * This function configures the queue node priority (Sibling Priority) of the
3737 struct ice_sched_node *node;
3739 node = ice_sched_find_node_by_teid(pi->root, q_ids[i]);
3740 if (!node || node->info.data.elem_type !=
3746 status = ice_sched_cfg_sibl_node_prio(pi, node, q_prio[i]);
3761 * @node_prio: pointer to node priority
3764 * This function configures the node priority (Sibling Priority) of the
3852 * node(s) for enabled traffic class.
4147 * ice_sched_cfg_node_bw_lmt - configure node sched params
4149 * @node: sched node to configure
4153 * This function configures node element's BW limit.
4156 ice_sched_cfg_node_bw_lmt(struct ice_hw *hw, struct ice_sched_node *node,
4162 buf = node->info;
4183 return ice_sched_update_elem(hw, node, &buf);
4187 * ice_sched_get_node_rl_prof_id - get node's rate limit profile ID
4188 * @node: sched node
4195 ice_sched_get_node_rl_prof_id(struct ice_sched_node *node,
4201 data = &node->info.data;
4267 * ice_sched_get_srl_node - get shared rate limit node
4268 * @node: tree node
4271 * This function returns SRL node to be used for shared rate limit purpose.
4275 ice_sched_get_srl_node(struct ice_sched_node *node, u8 srl_layer)
4277 if (srl_layer > node->tx_sched_layer)
4278 return node->children[0];
4279 else if (srl_layer < node->tx_sched_layer)
4281 * have a valid parent except root node.
4283 return node->parent;
4285 return node;
4330 * ice_sched_set_node_bw_dflt - set node's bandwidth limit to default
4332 * @node: pointer to node structure
4336 * This function configures node element's BW rate limit profile ID of
4342 struct ice_sched_node *node,
4370 old_id = ice_sched_get_node_rl_prof_id(node, rl_type);
4372 status = ice_sched_cfg_node_bw_lmt(hw, node, rl_type, rl_prof_id);
4385 * ice_sched_set_node_bw - set node's bandwidth
4387 * @node: tree node
4393 * node's RL profile ID of type CIR, EIR, or SRL, and removes old profile
4397 ice_sched_set_node_bw(struct ice_port_info *pi, struct ice_sched_node *node,
4412 old_id = ice_sched_get_node_rl_prof_id(node, rl_type);
4414 status = ice_sched_cfg_node_bw_lmt(hw, node, rl_type, rl_prof_id);
4433 * ice_sched_set_node_priority - set node's priority
4435 * @node: tree node
4438 * This function sets priority of a node among it's siblings.
4441 ice_sched_set_node_priority(struct ice_port_info *pi, struct ice_sched_node *node,
4447 buf = node->info;
4454 return ice_sched_update_elem(pi->hw, node, &buf);
4458 * ice_sched_set_node_weight - set node's weight
4460 * @node: tree node
4463 * This function sets weight of the node for WFQ algorithm.
4466 ice_sched_set_node_weight(struct ice_port_info *pi, struct ice_sched_node *node, u16 weight)
4471 buf = node->info;
4481 return ice_sched_update_elem(pi->hw, node, &buf);
4485 * ice_sched_set_node_bw_lmt - set node's BW limit
4487 * @node: tree node
4491 * It updates node's BW limit parameters like BW RL profile ID of type CIR,
4494 * NOTE: Caller provides the correct SRL node in case of shared profile
4498 ice_sched_set_node_bw_lmt(struct ice_port_info *pi, struct ice_sched_node *node,
4511 node->tx_sched_layer);
4516 return ice_sched_set_node_bw_dflt(pi, node, rl_type, layer_num);
4517 return ice_sched_set_node_bw(pi, node, rl_type, bw, layer_num);
4521 * ice_sched_set_node_bw_dflt_lmt - set node's BW limit to default
4523 * @node: pointer to node structure
4526 * This function configures node element's BW rate limit profile ID of
4532 struct ice_sched_node *node,
4535 return ice_sched_set_node_bw_lmt(pi, node, rl_type,
4540 * ice_sched_validate_srl_node - Check node for SRL applicability
4541 * @node: sched node to configure
4544 * This function checks if the SRL can be applied to a selceted layer node on
4545 * behalf of the requested node (first argument). This function needs to be
4549 ice_sched_validate_srl_node(struct ice_sched_node *node, u8 sel_layer)
4552 * SRL profile can be applied to a node above or below the
4553 * requested node. SRL configuration is possible only if the
4554 * selected layer's node has single child.
4556 if (sel_layer == node->tx_sched_layer ||
4557 ((sel_layer == node->tx_sched_layer + 1) &&
4558 node->num_children == 1) ||
4559 ((sel_layer == node->tx_sched_layer - 1) &&
4560 (node->parent && node->parent->num_children == 1)))
4567 * ice_sched_save_q_bw - save queue node's BW information
4572 * Save BW information of queue type node for post replay use.
4602 * This function sets BW limit of queue scheduling node.
4608 struct ice_sched_node *node;
4618 node = ice_sched_find_node_by_teid(pi->root, q_ctx->q_teid);
4619 if (!node) {
4624 /* Return error if it is not a leaf node */
4625 if (node->info.data.elem_type != ICE_AQC_ELEM_TYPE_LEAF)
4633 node->tx_sched_layer);
4638 status = ice_sched_validate_srl_node(node, sel_layer);
4644 status = ice_sched_set_node_bw_dflt_lmt(pi, node, rl_type);
4646 status = ice_sched_set_node_bw_lmt(pi, node, rl_type, bw);
4665 * This function configures BW limit of queue scheduling node.
4683 * This function configures BW default limit of queue scheduling node.
4694 * ice_sched_save_tc_node_bw - save TC node BW limit
4729 * ice_sched_set_tc_node_bw_lmt - sets TC node BW limit
4735 * This function configures bandwidth limit of TC node.
4753 /* update node's generic field */
4776 * ice_cfg_tc_node_bw_lmt - configure TC node BW limit
4782 * This function configures BW limit of TC node.
4793 * ice_cfg_tc_node_bw_dflt_lmt - configure TC node BW default limit
4798 * This function configures BW default limit of TC node.
4808 * ice_sched_save_tc_node_bw_alloc - save TC node's BW alloc information
4814 * Save BW alloc information of VSI type node for post replay use.
4838 * ice_sched_set_tc_node_bw_alloc - set TC node BW alloc
4844 * This function configures bandwidth alloc of TC node, also saves the
4873 * ice_cfg_tc_node_bw_alloc - configure TC node BW alloc
4879 * This function configures BW limit of TC node.
4890 * ice_sched_set_agg_bw_dflt_lmt - set aggregator node's BW limit to default
4895 * and sets node's BW limit to default. This function needs to be
4912 struct ice_sched_node *node;
4914 node = vsi_ctx->sched.ag_node[tc];
4915 if (!node)
4919 status = ice_sched_set_node_bw_dflt_lmt(pi, node, ICE_MIN_BW);
4924 status = ice_sched_set_node_bw_dflt_lmt(pi, node, ICE_MAX_BW);
4929 status = ice_sched_set_node_bw_dflt_lmt(pi, node,
4939 * ice_sched_get_node_by_id_type - get node from ID type
4945 * This function returns node identified by ID of type aggregator, and
4953 struct ice_sched_node *node = NULL;
4966 node = vsi_ctx->sched.vsi_node[tc];
4975 node = ice_sched_get_agg_node(pi, tc_node, id);
4981 node = ice_sched_find_node_by_teid(pi->root, id);
4991 node = child_node->parent;
4999 return node;
5003 * ice_sched_set_node_bw_lmt_per_tc - set node BW limit per TC
5006 * @agg_type: aggregator type (VSI or AGG type node)
5011 * This function sets BW limit of VSI or Aggregator scheduling node
5019 struct ice_sched_node *node;
5029 node = ice_sched_get_node_by_id_type(pi, id, agg_type, tc);
5030 if (!node) {
5035 status = ice_sched_set_node_bw_dflt_lmt(pi, node, rl_type);
5037 status = ice_sched_set_node_bw_lmt(pi, node, rl_type, bw);
5045 * ice_sched_validate_vsi_srl_node - validate VSI SRL node
5049 * This function validates SRL node of the VSI node if available SRL layer is
5050 * different than the VSI node layer on all TC(s).This function needs to be
5100 * @srl_node: sched node to configure
5127 * ice_sched_set_vsi_node_srl_per_tc - set VSI node BW shared limit for tc
5137 * is passed, it removes the corresponding bw from the node. The caller
5161 /* SRL node may be different */
5192 * passed, it removes those value(s) from the node.
5236 * ice_sched_validate_agg_srl_node - validate AGG SRL node
5240 * This function validates SRL node of the AGG node if available SRL layer is
5241 * different than the AGG node layer on all TC(s).This function needs to be
5329 * @srl_node: sched node to configure
5365 * node for a given traffic class for aggregator matching agg_id. When BW
5366 * value of ICE_SCHED_DFLT_BW is passed, it removes SRL from the node. Caller
5391 /* SRL node may be different */
5422 * node(s).
5473 * node for a given traffic class for aggregator matching agg_id. When BW
5474 * value of ICE_SCHED_DFLT_BW is passed, it removes SRL from the node.
5499 * ice_sched_cfg_sibl_node_prio - configure node sibling priority
5501 * @node: sched node to configure
5504 * This function configures node element's sibling priority only. This
5509 struct ice_sched_node *node, u8 priority)
5518 buf = node->info;
5527 status = ice_sched_update_elem(hw, node, &buf);
5573 * ice_sched_replay_node_prio - re-configure node priority
5575 * @node: sched node to configure
5578 * This function configures node element's priority value. It
5582 ice_sched_replay_node_prio(struct ice_hw *hw, struct ice_sched_node *node,
5589 buf = node->info;
5595 status = ice_sched_update_elem(hw, node, &buf);
5600 * ice_sched_replay_node_bw - replay node(s) BW
5602 * @node: sched node to configure
5605 * This function restores node's BW from bw_t_info. The caller needs
5609 ice_sched_replay_node_bw(struct ice_hw *hw, struct ice_sched_node *node,
5616 if (!node)
5621 status = ice_sched_replay_node_prio(hw, node,
5627 status = ice_sched_set_node_bw_lmt(pi, node, ICE_MIN_BW,
5634 status = ice_sched_cfg_node_bw_alloc(hw, node, ICE_MIN_BW,
5640 status = ice_sched_set_node_bw_lmt(pi, node, ICE_MAX_BW,
5647 status = ice_sched_cfg_node_bw_alloc(hw, node, ICE_MAX_BW,
5653 status = ice_sched_set_node_bw_lmt(pi, node, ICE_SHARED_BW,
5659 * ice_sched_replay_agg_bw - replay aggregator node(s) BW
5722 * ice_sched_replay_agg - recreate aggregator node(s)
5727 * associated with VSI type node yet.
5737 /* replay aggregator (re-create aggregator node) */
5759 /* Replay aggregator node BW (restore aggregator BW) */
5794 * ice_sched_replay_root_node_bw - replay root node BW
5797 * Replay root node BW settings.
5814 * ice_sched_replay_tc_node_bw - replay TC node(s) BW
5843 * ice_sched_replay_vsi_bw - replay VSI type node(s) BW
5883 * ice_sched_replay_vsi_agg - replay aggregator & VSI to aggregator node(s)
5887 * This function replays aggregator node, VSI to aggregator type nodes, and
5888 * their node bandwidth information. This function needs to be called with
5911 /* Replay aggregator node associated to vsi_handle */
5916 /* Replay aggregator node BW (restore aggregator BW) */
5935 * ice_replay_vsi_agg - replay VSI to aggregator node
5940 * node bandwidth information.
5954 * ice_sched_replay_q_bw - replay queue type node BW
5958 * This function replays queue type node bandwidth. This function needs to be
5966 /* Following also checks the presence of node in tree */