From patchwork Fri Mar 5 13:38:59 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Nithin Dabilpuram X-Patchwork-Id: 88560 X-Patchwork-Delegate: jerinj@marvell.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id C9649A0547; Fri, 5 Mar 2021 14:45:38 +0100 (CET) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id C335322A3BA; Fri, 5 Mar 2021 14:41:12 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0a-0016f401.pphosted.com [67.231.148.174]) by mails.dpdk.org (Postfix) with ESMTP id 6F18022A418 for ; Fri, 5 Mar 2021 14:41:10 +0100 (CET) Received: from pps.filterd (m0045849.ppops.net [127.0.0.1]) by mx0a-0016f401.pphosted.com (8.16.0.43/8.16.0.43) with SMTP id 125Df2e1001930 for ; Fri, 5 Mar 2021 05:41:09 -0800 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-type; s=pfpt0220; bh=bQUfqJ2D2K2BAJ/u5QxedAO496FfyI+nWY/UQlntILw=; b=CelSJTdj/3feaRwxlZMo+u4v4tzy4cEbC86OifKqe+xiu1YM6SGU01VFESO27vOaKIE9 YP9tvgImOlZBeHrMXGChzyezzDVszK6r1ThAhCNRW9crnds1ggi8VS5v2dXxDNSy7ULe ZNg2ffX33YEy/DKZIb2qA/rxTZ0KTa7xscBTjtyxbslrg50L+SgWPUEF3hPmpRPrBhAH uGKWqqSpqqB/NljJMrSn6Fwg+0jX+lnDSS+3zTHsdj3ksD6M6IC6VeCZKZLKwEhw4rtr 8a5VmVCHFUMre0g0CekZbqXip32HavLtq5+i+0elWStg6DijHgwzxSi4trcEC6q0bmYX ug== Received: from dc5-exch01.marvell.com ([199.233.59.181]) by mx0a-0016f401.pphosted.com with ESMTP id 372s2umrqd-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT) for ; Fri, 05 Mar 2021 05:41:09 -0800 Received: from SC-EXCH01.marvell.com (10.93.176.81) by DC5-EXCH01.marvell.com (10.69.176.38) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Fri, 5 Mar 2021 05:41:08 -0800 Received: from DC5-EXCH02.marvell.com (10.69.176.39) by SC-EXCH01.marvell.com (10.93.176.81) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Fri, 5 Mar 2021 05:41:07 -0800 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Fri, 5 Mar 2021 05:41:07 -0800 Received: from hyd1588t430.marvell.com (unknown [10.29.52.204]) by maili.marvell.com (Postfix) with ESMTP id DE42B3F703F; Fri, 5 Mar 2021 05:41:04 -0800 (PST) From: Nithin Dabilpuram To: CC: , , , , , , , Nithin Dabilpuram Date: Fri, 5 Mar 2021 19:08:59 +0530 Message-ID: <20210305133918.8005-34-ndabilpuram@marvell.com> X-Mailer: git-send-email 2.8.4 In-Reply-To: <20210305133918.8005-1-ndabilpuram@marvell.com> References: <20210305133918.8005-1-ndabilpuram@marvell.com> MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:6.0.369, 18.0.761 definitions=2021-03-05_08:2021-03-03, 2021-03-05 signatures=0 Subject: [dpdk-dev] [PATCH 33/52] common/cnxk: add nix tm support to add/delete node X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" Add support to add/delete nodes in a hierarchy. This patch also adds misc utils to get node name, walk through nodes etc. Signed-off-by: Nithin Dabilpuram Signed-off-by: Satha Rao --- drivers/common/cnxk/roc_nix.h | 42 +++++++ drivers/common/cnxk/roc_nix_priv.h | 14 +++ drivers/common/cnxk/roc_nix_tm.c | 205 +++++++++++++++++++++++++++++++ drivers/common/cnxk/roc_nix_tm_ops.c | 88 ++++++++++++++ drivers/common/cnxk/roc_nix_tm_utils.c | 212 +++++++++++++++++++++++++++++++++ drivers/common/cnxk/version.map | 7 ++ 6 files changed, 568 insertions(+) diff --git a/drivers/common/cnxk/roc_nix.h b/drivers/common/cnxk/roc_nix.h index b89851f..fbbea1b 100644 --- a/drivers/common/cnxk/roc_nix.h +++ b/drivers/common/cnxk/roc_nix.h @@ -294,6 +294,8 @@ void __roc_api roc_nix_unregister_cq_irqs(struct roc_nix *roc_nix); /* Traffic Management */ #define ROC_NIX_TM_MAX_SCHED_WT ((uint8_t)~0) +#define ROC_NIX_TM_SHAPER_PROFILE_NONE UINT32_MAX +#define ROC_NIX_TM_NODE_ID_INVALID UINT32_MAX enum roc_nix_tm_tree { ROC_NIX_TM_DEFAULT = 0, @@ -318,6 +320,46 @@ enum roc_tm_node_level { int __roc_api roc_nix_tm_sq_aura_fc(struct roc_nix_sq *sq, bool enable); int __roc_api roc_nix_tm_sq_flush_spin(struct roc_nix_sq *sq); +/* + * TM User hierarchy API. + */ + +struct roc_nix_tm_node { +#define ROC_NIX_TM_NODE_SZ (128) + uint8_t reserved[ROC_NIX_TM_NODE_SZ]; + + uint32_t id; + uint32_t parent_id; + uint32_t priority; + uint32_t weight; + uint32_t shaper_profile_id; + uint16_t lvl; + bool pkt_mode; + bool pkt_mode_set; + /* Function to free this memory */ + void (*free_fn)(void *node); +}; + +int __roc_api roc_nix_tm_node_add(struct roc_nix *roc_nix, + struct roc_nix_tm_node *roc_node); +int __roc_api roc_nix_tm_node_delete(struct roc_nix *roc_nix, uint32_t node_id, + bool free); +int __roc_api roc_nix_tm_node_pkt_mode_update(struct roc_nix *roc_nix, + uint32_t node_id, bool pkt_mode); + +struct roc_nix_tm_node *__roc_api roc_nix_tm_node_get(struct roc_nix *roc_nix, + uint32_t node_id); +struct roc_nix_tm_node *__roc_api +roc_nix_tm_node_next(struct roc_nix *roc_nix, struct roc_nix_tm_node *__prev); + +/* + * TM utilities API. + */ +int __roc_api roc_nix_tm_node_lvl(struct roc_nix *roc_nix, uint32_t node_id); +int __roc_api roc_nix_tm_node_name_get(struct roc_nix *roc_nix, + uint32_t node_id, char *buf, + size_t buflen); + /* MAC */ int __roc_api roc_nix_mac_rxtx_start_stop(struct roc_nix *roc_nix, bool start); int __roc_api roc_nix_mac_link_event_start_stop(struct roc_nix *roc_nix, diff --git a/drivers/common/cnxk/roc_nix_priv.h b/drivers/common/cnxk/roc_nix_priv.h index bd4a4e9..2f7c20e 100644 --- a/drivers/common/cnxk/roc_nix_priv.h +++ b/drivers/common/cnxk/roc_nix_priv.h @@ -325,14 +325,28 @@ int nix_tm_leaf_data_get(struct nix *nix, uint16_t sq, uint32_t *rr_quantum, int nix_tm_sq_flush_pre(struct roc_nix_sq *sq); int nix_tm_sq_flush_post(struct roc_nix_sq *sq); int nix_tm_smq_xoff(struct nix *nix, struct nix_tm_node *node, bool enable); +int nix_tm_node_add(struct roc_nix *roc_nix, struct nix_tm_node *node); +int nix_tm_node_delete(struct roc_nix *roc_nix, uint32_t node_id, + enum roc_nix_tm_tree tree, bool free); +int nix_tm_free_node_resource(struct nix *nix, struct nix_tm_node *node); int nix_tm_clear_path_xoff(struct nix *nix, struct nix_tm_node *node); /* * TM priv utils. */ +uint16_t nix_tm_lvl2nix(struct nix *nix, uint32_t lvl); +uint16_t nix_tm_lvl2nix_tl1_root(uint32_t lvl); +uint16_t nix_tm_lvl2nix_tl2_root(uint32_t lvl); +uint16_t nix_tm_resource_avail(struct nix *nix, uint8_t hw_lvl, bool contig); +int nix_tm_validate_prio(struct nix *nix, uint32_t lvl, uint32_t parent_id, + uint32_t priority, enum roc_nix_tm_tree tree); struct nix_tm_node *nix_tm_node_search(struct nix *nix, uint32_t node_id, enum roc_nix_tm_tree tree); +struct nix_tm_shaper_profile *nix_tm_shaper_profile_search(struct nix *nix, + uint32_t id); uint8_t nix_tm_sw_xoff_prep(struct nix_tm_node *node, bool enable, volatile uint64_t *reg, volatile uint64_t *regval); +struct nix_tm_node *nix_tm_node_alloc(void); +void nix_tm_node_free(struct nix_tm_node *node); #endif /* _ROC_NIX_PRIV_H_ */ diff --git a/drivers/common/cnxk/roc_nix_tm.c b/drivers/common/cnxk/roc_nix_tm.c index 8b26bc7..776d6b4 100644 --- a/drivers/common/cnxk/roc_nix_tm.c +++ b/drivers/common/cnxk/roc_nix_tm.c @@ -5,6 +5,100 @@ #include "roc_api.h" #include "roc_priv.h" +int +nix_tm_node_add(struct roc_nix *roc_nix, struct nix_tm_node *node) +{ + struct nix *nix = roc_nix_to_nix_priv(roc_nix); + struct nix_tm_shaper_profile *profile; + uint32_t node_id, parent_id, lvl; + struct nix_tm_node *parent_node; + uint32_t priority, profile_id; + uint8_t hw_lvl, exp_next_lvl; + enum roc_nix_tm_tree tree; + int rc; + + node_id = node->id; + priority = node->priority; + parent_id = node->parent_id; + profile_id = node->shaper_profile_id; + lvl = node->lvl; + tree = node->tree; + + plt_tm_dbg("Add node %s lvl %u id %u, prio 0x%x weight 0x%x " + "parent %u profile 0x%x tree %u", + nix_tm_hwlvl2str(nix_tm_lvl2nix(nix, lvl)), lvl, node_id, + priority, node->weight, parent_id, profile_id, tree); + + if (tree >= ROC_NIX_TM_TREE_MAX) + return NIX_ERR_PARAM; + + /* Translate sw level id's to nix hw level id's */ + hw_lvl = nix_tm_lvl2nix(nix, lvl); + if (hw_lvl == NIX_TXSCH_LVL_CNT && !nix_tm_is_leaf(nix, lvl)) + return NIX_ERR_TM_INVALID_LVL; + + /* Leaf nodes have to be same priority */ + if (nix_tm_is_leaf(nix, lvl) && priority != 0) + return NIX_ERR_TM_INVALID_PRIO; + + parent_node = nix_tm_node_search(nix, parent_id, tree); + + if (node_id < nix->nb_tx_queues) + exp_next_lvl = NIX_TXSCH_LVL_SMQ; + else + exp_next_lvl = hw_lvl + 1; + + /* Check if there is no parent node yet */ + if (hw_lvl != nix->tm_root_lvl && + (!parent_node || parent_node->hw_lvl != exp_next_lvl)) + return NIX_ERR_TM_INVALID_PARENT; + + /* Check if a node already exists */ + if (nix_tm_node_search(nix, node_id, tree)) + return NIX_ERR_TM_NODE_EXISTS; + + profile = nix_tm_shaper_profile_search(nix, profile_id); + if (!nix_tm_is_leaf(nix, lvl)) { + /* Check if shaper profile exists for non leaf node */ + if (!profile && profile_id != ROC_NIX_TM_SHAPER_PROFILE_NONE) + return NIX_ERR_TM_INVALID_SHAPER_PROFILE; + + /* Packet mode in profile should match with that of tm node */ + if (profile && profile->pkt_mode != node->pkt_mode) + return NIX_ERR_TM_PKT_MODE_MISMATCH; + } + + /* Check if there is second DWRR already in siblings or holes in prio */ + rc = nix_tm_validate_prio(nix, lvl, parent_id, priority, tree); + if (rc) + return rc; + + if (node->weight > ROC_NIX_TM_MAX_SCHED_WT) + return NIX_ERR_TM_WEIGHT_EXCEED; + + /* Maintain minimum weight */ + if (!node->weight) + node->weight = 1; + + node->hw_lvl = nix_tm_lvl2nix(nix, lvl); + node->rr_prio = 0xF; + node->max_prio = UINT32_MAX; + node->hw_id = NIX_TM_HW_ID_INVALID; + node->flags = 0; + + if (profile) + profile->ref_cnt++; + + node->parent = parent_node; + if (parent_node) + parent_node->child_realloc = true; + node->parent_hw_id = NIX_TM_HW_ID_INVALID; + + TAILQ_INSERT_TAIL(&nix->trees[tree], node, node); + plt_tm_dbg("Added node %s lvl %u id %u (%p)", + nix_tm_hwlvl2str(node->hw_lvl), lvl, node_id, node); + return 0; +} int nix_tm_clear_path_xoff(struct nix *nix, struct nix_tm_node *node) @@ -321,6 +415,115 @@ nix_tm_sq_flush_post(struct roc_nix_sq *sq) } int +nix_tm_free_node_resource(struct nix *nix, struct nix_tm_node *node) +{ + struct mbox *mbox = (&nix->dev)->mbox; + struct nix_txsch_free_req *req; + struct plt_bitmap *bmp; + uint16_t avail, hw_id; + uint8_t hw_lvl; + int rc = -ENOSPC; + + hw_lvl = node->hw_lvl; + hw_id = node->hw_id; + bmp = nix->schq_bmp[hw_lvl]; + /* Free specific HW resource */ + plt_tm_dbg("Free hwres %s(%u) lvl %u id %u (%p)", + nix_tm_hwlvl2str(node->hw_lvl), hw_id, node->lvl, node->id, + node); + + avail = nix_tm_resource_avail(nix, hw_lvl, false); + /* Always for now free to discontiguous queue when avail + * is not sufficient. + */ + if (nix->discontig_rsvd[hw_lvl] && + avail < nix->discontig_rsvd[hw_lvl]) { + PLT_ASSERT(hw_id < NIX_TM_MAX_HW_TXSCHQ); + PLT_ASSERT(plt_bitmap_get(bmp, hw_id) == 0); + plt_bitmap_set(bmp, hw_id); + node->hw_id = NIX_TM_HW_ID_INVALID; + node->flags &= ~NIX_TM_NODE_HWRES; + return 0; + } + + /* Free to AF */ + req = mbox_alloc_msg_nix_txsch_free(mbox); + if (req == NULL) + return rc; + req->flags = 0; + req->schq_lvl = node->hw_lvl; + req->schq = hw_id; + rc = mbox_process(mbox); + if (rc) { + plt_err("failed to release hwres %s(%u) rc %d", + nix_tm_hwlvl2str(node->hw_lvl), hw_id, rc); + return rc; + } + + /* Mark parent as dirty for reallocing it's children */ + if (node->parent) + node->parent->child_realloc = true; + + node->hw_id = NIX_TM_HW_ID_INVALID; + node->flags &= ~NIX_TM_NODE_HWRES; + plt_tm_dbg("Released hwres %s(%u) to af", + nix_tm_hwlvl2str(node->hw_lvl), hw_id); + return 0; +} + +int +nix_tm_node_delete(struct roc_nix *roc_nix, uint32_t node_id, + enum roc_nix_tm_tree tree, bool free) +{ + struct nix *nix = roc_nix_to_nix_priv(roc_nix); + struct nix_tm_shaper_profile *profile; + struct nix_tm_node *node, *child; + struct nix_tm_node_list *list; + uint32_t profile_id; + int rc; + + plt_tm_dbg("Delete node id %u tree %u", node_id, tree); + + node = nix_tm_node_search(nix, node_id, tree); + if (!node) + return NIX_ERR_TM_INVALID_NODE; + + list = nix_tm_node_list(nix, tree); + /* Check for any existing children */ + TAILQ_FOREACH(child, list, node) { + if (child->parent == node) + return NIX_ERR_TM_CHILD_EXISTS; + } + + /* Remove shaper profile reference */ + profile_id = node->shaper_profile_id; + profile = nix_tm_shaper_profile_search(nix, profile_id); + + /* Free hw resource locally */ + if (node->flags & NIX_TM_NODE_HWRES) { + rc = nix_tm_free_node_resource(nix, node); + if (rc) + return rc; + } + + if (profile) + profile->ref_cnt--; + + TAILQ_REMOVE(list, node, node); + + plt_tm_dbg("Deleted node %s lvl %u id %u, prio 0x%x weight 0x%x " + "parent %u profile 0x%x tree %u (%p)", + nix_tm_hwlvl2str(node->hw_lvl), node->lvl, node->id, + node->priority, node->weight, + node->parent ? node->parent->id : UINT32_MAX, + node->shaper_profile_id, tree, node); + /* Free only if requested */ + if (free) + nix_tm_node_free(node); + return 0; +} + +int nix_tm_conf_init(struct roc_nix *roc_nix) { struct nix *nix = roc_nix_to_nix_priv(roc_nix); @@ -328,6 +531,8 @@ nix_tm_conf_init(struct roc_nix *roc_nix) void *bmp_mem; int rc, i; + PLT_STATIC_ASSERT(sizeof(struct nix_tm_node) <= ROC_NIX_TM_NODE_SZ); + nix->tm_flags = 0; for (i = 0; i < ROC_NIX_TM_TREE_MAX; i++) TAILQ_INIT(&nix->trees[i]); diff --git a/drivers/common/cnxk/roc_nix_tm_ops.c b/drivers/common/cnxk/roc_nix_tm_ops.c index a3f6de0..ede30fa 100644 --- a/drivers/common/cnxk/roc_nix_tm_ops.c +++ b/drivers/common/cnxk/roc_nix_tm_ops.c @@ -65,3 +65,91 @@ roc_nix_tm_sq_aura_fc(struct roc_nix_sq *sq, bool enable) plt_wmb(); return 0; } + +int +roc_nix_tm_node_add(struct roc_nix *roc_nix, struct roc_nix_tm_node *roc_node) +{ + struct nix_tm_node *node; + + node = (struct nix_tm_node *)&roc_node->reserved; + node->id = roc_node->id; + node->priority = roc_node->priority; + node->weight = roc_node->weight; + node->lvl = roc_node->lvl; + node->parent_id = roc_node->parent_id; + node->shaper_profile_id = roc_node->shaper_profile_id; + node->pkt_mode = roc_node->pkt_mode; + node->pkt_mode_set = roc_node->pkt_mode_set; + node->free_fn = roc_node->free_fn; + node->tree = ROC_NIX_TM_USER; + + return nix_tm_node_add(roc_nix, node); +} + +int +roc_nix_tm_node_pkt_mode_update(struct roc_nix *roc_nix, uint32_t node_id, + bool pkt_mode) +{ + struct nix *nix = roc_nix_to_nix_priv(roc_nix); + struct nix_tm_node *node, *child; + struct nix_tm_node_list *list; + int num_children = 0; + + node = nix_tm_node_search(nix, node_id, ROC_NIX_TM_USER); + if (!node) + return NIX_ERR_TM_INVALID_NODE; + + if (node->pkt_mode == pkt_mode) { + node->pkt_mode_set = true; + return 0; + } + + /* Check for any existing children, if there are any, + * then we cannot update the pkt mode as children's quantum + * are already taken in. + */ + list = nix_tm_node_list(nix, ROC_NIX_TM_USER); + TAILQ_FOREACH(child, list, node) { + if (child->parent == node) + num_children++; + } + + /* Cannot update mode if it has children or tree is enabled */ + if ((nix->tm_flags & NIX_TM_HIERARCHY_ENA) && num_children) + return -EBUSY; + + if (node->pkt_mode_set && num_children) + return NIX_ERR_TM_PKT_MODE_MISMATCH; + + node->pkt_mode = pkt_mode; + node->pkt_mode_set = true; + + return 0; +} + +int +roc_nix_tm_node_name_get(struct roc_nix *roc_nix, uint32_t node_id, char *buf, + size_t buflen) +{ + struct nix *nix = roc_nix_to_nix_priv(roc_nix); + struct nix_tm_node *node; + + node = nix_tm_node_search(nix, node_id, ROC_NIX_TM_USER); + if (!node) { + plt_strlcpy(buf, "???", buflen); + return NIX_ERR_TM_INVALID_NODE; + } + + if (node->hw_lvl == NIX_TXSCH_LVL_CNT) + snprintf(buf, buflen, "SQ_%d", node->id); + else + snprintf(buf, buflen, "%s_%d", nix_tm_hwlvl2str(node->hw_lvl), + node->hw_id); + return 0; +} + +int +roc_nix_tm_node_delete(struct roc_nix *roc_nix, uint32_t node_id, bool free) +{ + return nix_tm_node_delete(roc_nix, node_id, ROC_NIX_TM_USER, free); +} diff --git a/drivers/common/cnxk/roc_nix_tm_utils.c b/drivers/common/cnxk/roc_nix_tm_utils.c index 86f66cf..09cb693 100644 --- a/drivers/common/cnxk/roc_nix_tm_utils.c +++ b/drivers/common/cnxk/roc_nix_tm_utils.c @@ -5,6 +5,64 @@ #include "roc_api.h" #include "roc_priv.h" +uint16_t +nix_tm_lvl2nix_tl1_root(uint32_t lvl) +{ + switch (lvl) { + case ROC_TM_LVL_ROOT: + return NIX_TXSCH_LVL_TL1; + case ROC_TM_LVL_SCH1: + return NIX_TXSCH_LVL_TL2; + case ROC_TM_LVL_SCH2: + return NIX_TXSCH_LVL_TL3; + case ROC_TM_LVL_SCH3: + return NIX_TXSCH_LVL_TL4; + case ROC_TM_LVL_SCH4: + return NIX_TXSCH_LVL_SMQ; + default: + return NIX_TXSCH_LVL_CNT; + } +} + +uint16_t +nix_tm_lvl2nix_tl2_root(uint32_t lvl) +{ + switch (lvl) { + case ROC_TM_LVL_ROOT: + return NIX_TXSCH_LVL_TL2; + case ROC_TM_LVL_SCH1: + return NIX_TXSCH_LVL_TL3; + case ROC_TM_LVL_SCH2: + return NIX_TXSCH_LVL_TL4; + case ROC_TM_LVL_SCH3: + return NIX_TXSCH_LVL_SMQ; + default: + return NIX_TXSCH_LVL_CNT; + } +} + +uint16_t +nix_tm_lvl2nix(struct nix *nix, uint32_t lvl) +{ + if (nix_tm_have_tl1_access(nix)) + return nix_tm_lvl2nix_tl1_root(lvl); + else + return nix_tm_lvl2nix_tl2_root(lvl); +} + + +struct nix_tm_shaper_profile * +nix_tm_shaper_profile_search(struct nix *nix, uint32_t id) +{ + struct nix_tm_shaper_profile *profile; + + TAILQ_FOREACH(profile, &nix->shaper_profile_list, shaper) { + if (profile->id == id) + return profile; + } + return NULL; +} + struct nix_tm_node * nix_tm_node_search(struct nix *nix, uint32_t node_id, enum roc_nix_tm_tree tree) { @@ -19,6 +77,70 @@ nix_tm_node_search(struct nix *nix, uint32_t node_id, enum roc_nix_tm_tree tree) return NULL; } +static uint16_t +nix_tm_max_prio(struct nix *nix, uint16_t hw_lvl) +{ + if (hw_lvl >= NIX_TXSCH_LVL_CNT) + return 0; + + /* MDQ does not support SP */ + if (hw_lvl == NIX_TXSCH_LVL_MDQ) + return 0; + + /* PF's TL1 with VF's enabled does not support SP */ + if (hw_lvl == NIX_TXSCH_LVL_TL1 && (!nix_tm_have_tl1_access(nix) || + (nix->tm_flags & NIX_TM_TL1_NO_SP))) + return 0; + + return NIX_TM_TLX_SP_PRIO_MAX - 1; +} + +int +nix_tm_validate_prio(struct nix *nix, uint32_t lvl, uint32_t parent_id, + uint32_t priority, enum roc_nix_tm_tree tree) +{ + uint8_t priorities[NIX_TM_TLX_SP_PRIO_MAX]; + struct nix_tm_node_list *list; + struct nix_tm_node *node; + uint32_t rr_num = 0; + int i; + + list = nix_tm_node_list(nix, tree); + /* Validate priority against max */ + if (priority > nix_tm_max_prio(nix, nix_tm_lvl2nix(nix, lvl - 1))) + return NIX_ERR_TM_PRIO_EXCEEDED; + + if (parent_id == ROC_NIX_TM_NODE_ID_INVALID) + return 0; + + memset(priorities, 0, sizeof(priorities)); + priorities[priority] = 1; + + TAILQ_FOREACH(node, list, node) { + if (!node->parent) + continue; + + if (node->parent->id != parent_id) + continue; + + priorities[node->priority]++; + } + + for (i = 0; i < NIX_TM_TLX_SP_PRIO_MAX; i++) + if (priorities[i] > 1) + rr_num++; + + /* At max, one rr groups per parent */ + if (rr_num > 1) + return NIX_ERR_TM_MULTIPLE_RR_GROUPS; + + /* Check for previous priority to avoid holes in priorities */ + if (priority && !priorities[priority - 1]) + return NIX_ERR_TM_PRIO_ORDER; + + return 0; +} + uint8_t nix_tm_sw_xoff_prep(struct nix_tm_node *node, bool enable, volatile uint64_t *reg, volatile uint64_t *regval) @@ -60,3 +182,93 @@ nix_tm_sw_xoff_prep(struct nix_tm_node *node, bool enable, return k; } + +uint16_t +nix_tm_resource_avail(struct nix *nix, uint8_t hw_lvl, bool contig) +{ + uint32_t pos = 0, start_pos = 0; + struct plt_bitmap *bmp; + uint16_t count = 0; + uint64_t slab = 0; + + bmp = contig ? nix->schq_contig_bmp[hw_lvl] : nix->schq_bmp[hw_lvl]; + plt_bitmap_scan_init(bmp); + + if (!plt_bitmap_scan(bmp, &pos, &slab)) + return count; + + /* Count bit set */ + start_pos = pos; + do { + count += __builtin_popcountll(slab); + if (!plt_bitmap_scan(bmp, &pos, &slab)) + break; + } while (pos != start_pos); + + return count; +} + +int +roc_nix_tm_node_lvl(struct roc_nix *roc_nix, uint32_t node_id) +{ + struct nix *nix = roc_nix_to_nix_priv(roc_nix); + struct nix_tm_node *node; + + node = nix_tm_node_search(nix, node_id, ROC_NIX_TM_USER); + if (!node) + return NIX_ERR_TM_INVALID_NODE; + + return node->lvl; +} + +struct roc_nix_tm_node * +roc_nix_tm_node_get(struct roc_nix *roc_nix, uint32_t node_id) +{ + struct nix *nix = roc_nix_to_nix_priv(roc_nix); + struct nix_tm_node *node; + + node = nix_tm_node_search(nix, node_id, ROC_NIX_TM_USER); + return (struct roc_nix_tm_node *)node; +} + +struct roc_nix_tm_node * +roc_nix_tm_node_next(struct roc_nix *roc_nix, struct roc_nix_tm_node *__prev) +{ + struct nix_tm_node *prev = (struct nix_tm_node *)__prev; + struct nix *nix = roc_nix_to_nix_priv(roc_nix); + struct nix_tm_node_list *list; + + list = nix_tm_node_list(nix, ROC_NIX_TM_USER); + + /* HEAD of the list */ + if (!prev) + return (struct roc_nix_tm_node *)TAILQ_FIRST(list); + + /* Next entry */ + if (prev->tree != ROC_NIX_TM_USER) + return NULL; + + return (struct roc_nix_tm_node *)TAILQ_NEXT(prev, node); +} + +struct nix_tm_node * +nix_tm_node_alloc(void) +{ + struct nix_tm_node *node; + + node = plt_zmalloc(sizeof(struct nix_tm_node), 0); + if (!node) + return NULL; + + node->free_fn = plt_free; + return node; +} + +void +nix_tm_node_free(struct nix_tm_node *node) +{ + if (!node || node->free_fn == NULL) + return; + + (node->free_fn)(node); +} diff --git a/drivers/common/cnxk/version.map b/drivers/common/cnxk/version.map index c146137..0f70fff 100644 --- a/drivers/common/cnxk/version.map +++ b/drivers/common/cnxk/version.map @@ -103,6 +103,13 @@ INTERNAL { roc_nix_xstats_names_get; roc_nix_switch_hdr_set; roc_nix_eeprom_info_get; + roc_nix_tm_node_add; + roc_nix_tm_node_delete; + roc_nix_tm_node_get; + roc_nix_tm_node_lvl; + roc_nix_tm_node_name_get; + roc_nix_tm_node_next; + roc_nix_tm_node_pkt_mode_update; roc_nix_tm_sq_aura_fc; roc_nix_tm_sq_flush_spin; roc_nix_unregister_cq_irqs;