From patchwork Mon May 22 09:39:17 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Hemant Agrawal X-Patchwork-Id: 24433 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [IPv6:::1]) by dpdk.org (Postfix) with ESMTP id 2A18B5A98; Mon, 22 May 2017 11:40:18 +0200 (CEST) Received: from NAM03-BY2-obe.outbound.protection.outlook.com (mail-by2nam03on0057.outbound.protection.outlook.com [104.47.42.57]) by dpdk.org (Postfix) with ESMTP id 238F737A6 for ; Mon, 22 May 2017 11:40:05 +0200 (CEST) Received: from BN6PR03CA0042.namprd03.prod.outlook.com (10.175.124.28) by DM2PR0301MB0912.namprd03.prod.outlook.com (10.160.217.142) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1101.14; Mon, 22 May 2017 09:40:03 +0000 Received: from BL2FFO11FD017.protection.gbl (2a01:111:f400:7c09::162) by BN6PR03CA0042.outlook.office365.com (2603:10b6:404:10c::28) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1101.14 via Frontend Transport; Mon, 22 May 2017 09:40:02 +0000 Authentication-Results: spf=fail (sender IP is 192.88.168.50) smtp.mailfrom=nxp.com; nxp.com; dkim=none (message not signed) header.d=none;nxp.com; dmarc=fail action=none header.from=nxp.com; Received-SPF: Fail (protection.outlook.com: domain of nxp.com does not designate 192.88.168.50 as permitted sender) receiver=protection.outlook.com; client-ip=192.88.168.50; helo=tx30smr01.am.freescale.net; Received: from tx30smr01.am.freescale.net (192.88.168.50) by BL2FFO11FD017.mail.protection.outlook.com (10.173.161.35) with Microsoft SMTP Server (version=TLS1_0, cipher=TLS_RSA_WITH_AES_256_CBC_SHA) id 15.1.1075.5 via Frontend Transport; Mon, 22 May 2017 09:40:01 +0000 Received: from bf-netperf1.ap.freescale.net (bf-netperf1.ap.freescale.net [10.232.134.28]) by tx30smr01.am.freescale.net (8.14.3/8.14.0) with ESMTP id v4M9dk43031538; Mon, 22 May 2017 02:40:00 -0700 From: Hemant Agrawal To: CC: , Date: Mon, 22 May 2017 15:09:17 +0530 Message-ID: <1495445969-29199-9-git-send-email-hemant.agrawal@nxp.com> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1495445969-29199-1-git-send-email-hemant.agrawal@nxp.com> References: <1494851864-26029-1-git-send-email-hemant.agrawal@nxp.com> <1495445969-29199-1-git-send-email-hemant.agrawal@nxp.com> X-EOPAttributedMessage: 0 X-Matching-Connectors: 131399196020878241; (91ab9b29-cfa4-454e-5278-08d120cd25b8); () X-Forefront-Antispam-Report: CIP:192.88.168.50; IPV:NLI; CTRY:US; EFV:NLI; SFV:NSPM; SFS:(10009020)(6009001)(336005)(39400400002)(39850400002)(39380400002)(39840400002)(39450400003)(39860400002)(39410400002)(2980300002)(1109001)(1110001)(339900001)(189002)(199003)(9170700003)(8656002)(6666003)(105606002)(86362001)(2950100002)(6916009)(104016004)(106466001)(2351001)(54906002)(77096006)(47776003)(50986999)(33646002)(76176999)(36756003)(5003940100001)(305945005)(15650500001)(498600001)(8676002)(81166006)(8936002)(50226002)(5660300001)(85426001)(356003)(2906002)(4326008)(50466002)(189998001)(48376002)(38730400002)(110136004)(53936002); DIR:OUT; SFP:1101; SCL:1; SRVR:DM2PR0301MB0912; H:tx30smr01.am.freescale.net; FPR:; SPF:Fail; MLV:ovrnspm; MX:1; A:1; PTR:InfoDomainNonexistent; LANG:en; X-Microsoft-Exchange-Diagnostics: 1; BL2FFO11FD017; 1:PyLBgF6DFhEFwG2PFbbHNi8OobkL30NP1GRIOZGU9zh1SIjyYmXrzj47Uc7h1kyzV1hK9CqCk/1BfAgZF8Tr2cejxSwkw3AbV5+YcZsv8bfZekTb9CX+z8I3F71R+AtG+EFCDwk7lbWilE56+qFIeqHjdFC4q62HzgoAu5xqouHrXU3b1MUAjnpFrN886pp3th1oNW+oKtMdSaaN1705wXAdpl92LCjhJEJg9spwYEhZah3df1hhk3kpM8RS2XX6HkYf71HblmMtYrnAW3kHDNUQ/Ll+pRYXHXRmOBeVtlfCTEqU4jWQnPKdHrUmoZ0c0Qt/XzPXk8zlYq1uU7nz1CrOgWathBNJqJVVowYGCqjZNxH+KnBxKYw/RmZOvyGwiV0Dvbctw7XQ9YK7xGK2M74LrJ0g3FjrtsilmPt8tL2KF+jyg6F+2uvE8SGk0f3qBSn7leyu9rm4IZkc9gG2mrhQpYp5znE5T7rM2cad/YnB5EU4lJWcoOsBeEKE4t7NqME6t19HACVsRb+HQ9EbKS0ThqzYJesZpJhqIfRdnuGNckk8g1XqjYRaiC02z4RSrVm1B7GB8+dMM78bqgySI3Qs8CfL4/Iw2wWEGWVIfqulV6w6tPPynZ07ryDn+v1xBR5WAksElSjyrD9kZp+oEIEz+9aEq+XqeCOVteE5FaKL4d6X7U49Ot+/JTdgemBb/OsNovd7dGY6Flle22eyeAxOupK3A8ryMuJcWi58t8H1Im2TXFa2LFJ0fP0//sCGcyVhVcopBlxHgz28iGG5Bg== MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: DM2PR0301MB0912: X-MS-Office365-Filtering-Correlation-Id: c4844e2f-9de7-49ba-aba1-08d4a0f6850f X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(22001)(201703131430075)(201703131517081); SRVR:DM2PR0301MB0912; X-Microsoft-Exchange-Diagnostics: 1; DM2PR0301MB0912; 3:FuknnHAqR1lI0HVRFxtU2klKDPUrpZCXUgpvHRLWloZ2Ly0Y5N7pgLCGsjiXOxbDcaLVHyHXvkWQ5cLaqm2tJurQoRFwUG86bYeI0xxCd4bBYelDLMXgwnQAgOICeE2SDgarkhUFylOa5nrx9qioBtjnrTcQTTbvNeEvCYNjkuqRpqhbkIIPs6+v31mdcFDRfJ7cLDjgDUkLC/k5WdjjBmjg34fbzAj9f3LDfvJT4gyNE8lwF7Z/ghaHf0PFksguxVClhHG9jIOYwsnggHyT0IF+VlR72GLcGM7wU5C2IEzUYi5M210ImvbFKCcuUIXDHv1enhww3/vS8Vh+ln78xnsdKDwkE/2+sOkfW8XQE1Ua5VdSIcIti/Um0jWOUY+a47lCtcMEJBxiRLw5KiGwbyrNhrVigzp1xSDFnQHCmIM1WsXpJhuk9Sy8OT7llKJE; 25:j0aoGjrWkXeQJlOAWPwO+1b2oo5S2KvH6dPV/BOAPUBGLWxhH1f9lWP+lKuugBoluydjnGqXquLkaqAyWoP8p0S4UqtCD1j3ehr9kCSYmpAw3ngtHgnWH9ia206apidM7tXlvP+gY2eBcWVl08SGL1xWw4or5RHP0K4KNJ0kP3P+vZiXb/K9l0hh29pNMEVedhmUG1lS3LsSKVTPV0nU4fBGkRzZXtFnW8B8KY4GhL6huhkkKRKikz2CRGfmUlE3IkPXvYz6JJB1+Qi12jy3UtnZIvogTi4ocExku7gcgLqxrI4hIYTwRjUfAQHB+DRc4Agc0/xaZQx1yX3pTgL3TpuOL9IyyXRQS/EHThwLG4NvbTMFsPaWdYsvTY6MbPKjcNsy5yj2u8QcSFNLQW+33B4dyQOVcMei6foWcBCmu/26PBrQIMhN6p5cNklgUiOfbFpLOMjinWSpYvYXoeSolPLOpNc4yfUG4QqWFqMneJE= X-Microsoft-Exchange-Diagnostics: 1; DM2PR0301MB0912; 31:5vuWwhGU3gx7e9ySaDn/IrOBvLIw2G2vJMy9Myzvzv/8hhozJM7maJ1jyuEga7lsdWgmVdknm1BYqDpRhTGQ0RtudI+N3BIaID91+1aRZf9zgeoUu7G8rqj+C+/XLx9mKlpUYypWaZHNQL0F9w/ACGnBJa+/X92FnlnIS0NMgJ4XGqlxAh2T5HXLLtcavZ7dnLpiUhmE9RTMPIxqmzGjPbIFEvHmEjMVeraDAS1z31zGRpII1jXXLUP5hD7vsTCwuiW+gimM8TGJ9jU1DyBefg== X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(185117386973197)(275809806118684); X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(6095135)(601004)(2401047)(5005006)(13015025)(13017025)(13023025)(13024025)(8121501046)(13018025)(3002001)(93006095)(93001095)(10201501046)(6055026)(6096035)(20161123559100)(20161123556025)(20161123561025)(20161123563025)(20161123565025)(201703131430075)(201703131448075)(201703131433075)(201703161259150)(201703151042153); SRVR:DM2PR0301MB0912; BCL:0; PCL:0; RULEID:(400006); SRVR:DM2PR0301MB0912; X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; DM2PR0301MB0912; 4:Vub+mOyUK215PYW9n5ASDy7TxKQvwM++iX0/e4I2?= /StfBojqOJOuiafhQIB/OHteDbyaYJArlqfINkZxJKDK3diPBUlC5tYWRxiHqYqGODrqYqeFGMuD16De1c/rjHIJS5sn1T+VDbhAnILIA5Jtqt4x9rdqL6krkDL9NzbP9ug3WT9amJocGixwZSWHgaUehs/3oS8Bdww9CahFqNicMtynzOj8r0Er/VBL9ZPeprDyObf7xe5MyVOOOi+CxMxUtxUWE+wqP7RGCkTM/MQ2foDx9XBcwRIID/dNcXqueOVtDi5k5G7p4jx0tA1BWUkU+MOgZFDil4rSeA1h4ehDLtuXduMLU5fvWvhSe4U04gq+OfSXuGeJdg+ntY63lF0u64NeNOf8kvqhq2I+rdxtP1zK2b9lz3aLFPqISM1YKJZ2J4nvSx2LxWaTgZyzCsuxnf6NTdITKptk4bEQ2ZgkLClIvp2krQbG8cmwOvvQpFytWkpuT9BeYKZ6kMkw5VmIMJCpiodWBngDwlPAjb+C1v2VDcDxJW2YTCeMlKw22NgzJsOXycMOGHoQerkxUshauLA4XsTXcsuP7316K9uIOpsv3X0Fo1S28B8FBL5XMbmuLlUuwB2sRTBjiD5bQsXcjXQwHsG/vvbezaDKK5qGlyJZgQoaESngzmoCm/9T63CD7cDsg0T7JWkD2d3LaPDAqR7PxAClGVGOW6lKexyh0mbWO2ivmxHM7+tP2vunXQ40X1p0enhsan/LXiLeJUxpFLM8cpu8mBaQRUMMxu4HDefgxdB6a4mZvVIMShrPCgLQsW/1g9/TLlFS1I0QTspBk3hHvkZquiuxfinJNQQfqDm/EhVz+ey3sW1zKhwHpGO+xuQj4RVeHuyqcMQw0kmQsn1JVnHrsCQyPuifb+6ZXEaazWGJaecAiMZdgEaMRiI70f3icJ/nn63eULaNbJ6QxxzRuUB4M1e7lMmKSr+uC5MZOBw6NzuetHCmlCa2xf0= X-Forefront-PRVS: 03152A99FF X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; DM2PR0301MB0912; 23:oIObANodUWiXgr3l2Mjg6t9hZ8SMqtGpcKyADE6?= zsGTZ3S4/m7JL8EKUy3Up93er3LDr9fV6SiZhA0tmFmBlEKOjs23REqgh3WJevDdkh1duBEKCNZK+GptG1hmokg6E9e29exUhk5Wsq5Q1z6zaPqVuHM80YOPHe/XmfkmSh1wu8FRkl/QB37k5zo5fzQmTjhwUhQslJcKtZiGEwQdZWIL4LApXQFlGqoKNUa2uCy2+iPSNUPA9t5StTHfLXkXgMiUv+cHHJ672GnGcinaP77s2cBHldT4BRYQrJ2F+y4a0M6oJHSn45nUKY9nxYEN3xxFDNY3KJjGjO9hibMjs706PSHxkctAVC4wMR2Mo7pyFmxvjRrlHDSA2VkgFsJqgaGXXFx+x13sGrLy5n+kEi5Lm7biySymyuP2DX2AyGenP+GLZkimMXYLIEABMjTmwGuqzfdZSrDzfWpcTry0jIhOeLyHfuGIg9/5B/tHHE19QP1ksEgd+6IsuRuAfFTTdoFkCJ8Bi2ECYcc25fodTr1i+oVSvQhRht9600hxEi+XyE46eyDbOjbxAIq7xijaSTDbnQZhtpfD6GL45e2WpTcFgMMN8pfSN2ctmXxh5f681xkwZ7a1vOVxUbp+2hHew6+1YRmxOYYS1LszLyggqXAYu5zNn5PoHckyziUoEoYG9yQezxKEOBFmdKEHbrxDe4mE63+N46HGGluf4wJ7T0UlHi2OrpEIDDSHXwnwA37jerOWaJ4NA9n5SVjGZ4Ci19IzuAWkYBrZz0xEZHX2TSiFkqcWE6AVkNFcuFWzjOvXfMKEjkn7/lONSXBwPt5nG80fmZVMAeFVA8IbC1q1bqYKUZcNkYteLbgx146ekbUCXbKYFhSbgwWpoWx/OkXiZrsulmQhRIh1tH8d4p2YK+sdYkKZmTqs6vGTRVnzSjbEv0q6OF5m6DCVkIS+bTYz1NJJqaf158YvYFklAI0NQl4bn++Xo+QMyY6Js/J1x13zV37eok2yr5uYpoHiptXLWY4bMl+LikSMNlcJ8cB5BPn//+jrc4DsqOd8J6EtWUh4gso4GA8a0WbbEb//jGOOqRMOjVJSy5W+7FBWcZqR4o9ZVqly9wJLTCt1/DgIlF5ok82Es/CXLYmybJpAgF+/0g3Fl6pNMbC4L7H2Hbexa5NJQxQUjmsM8ZjBUuNOmXEGLHz3+WpFUYlKIWdDFZ6hhwrHWccWhbYCS/NRRh7+A5lLtw+F4QVmNOHdAkLJPbQ9OvLMj5iDMDbLL8WU+cIkC X-Microsoft-Exchange-Diagnostics: 1; DM2PR0301MB0912; 6:ODMFM+L/aJQBMbWRVuhDoIRQ9GtjiwcR7H378FWTh2x7Z95HCLsGUaPdpma0C2XzI29QJug9BNjy5Y0ab11V8VeYFyEKOKMW+MKkmuCdVnwMVPK1OUyhNcjL52QcE3ePvbvLJKqje+9lxRbEzAHLcpvrMY6hUu/+AJsjdP3LJWtxT4qLAjIC+t7eIsEyhtw/nHt8PFyGV3Jhzn5/3FggTwAkAqfnqN/pV1EUwK0zD8Uw+E7wXBCXFq8usJLrngyx+UA1BXkx8wzv53HiFwCKwt2HZxhSONIOAAWujfgokcXNvE7KWSVcCBvq/ZhydMWGdlFUW1u709u84T5XNLxjtHYoALqVPSQhLRmekdxRAd/zbtjoDfszwxuBmMDV5PcCTKENnVt2anM9BUZ+JUtBzO3Ai7qXgltS3E29qgItL3bmf/EBgq7bxrm9Q42mEnZm2tg/Fg4i6CbOvIk2+QCDwVtYNWzdVGv4gz1+9jcgdnphbu0EaLz5WbiraSkgQY2mb/JJBc9NsMlq+M23nROhmg==; 5:GtdnvkxVnH5k4R4G7upzHDS30tzLH2sWOydLK7VgesrsqcWGLiwF/cSb+EzVfa8qeC0D8XyN3EMvPvfQMGbAI/FNmgFpS0iAus3L+9ID5IrqJxzsDoeaPXK4x19vC4IZhA+NJk6cuQGZfdiCo2GARkgWlZ06YDljlVSPynY57TEyGm79fSLOi8n+iFO3pmrU; 24:+9oCT2Hrrnk2BqycQb32JQm+WzHPVf1GKQDDxgLJVop1JXaQKU4yMgbTTjKlgBWkfxHtZTxL5Pi2W7+zb01ZaMyFBSCl5Z3JWZ18Tao2jr4= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; DM2PR0301MB0912; 7:vyUuh1ZkreRnfXF1oMckMO2P+UyiCw+p4KQht67lVyZ2i1g81+diTIvwavEH86VzviK9c8hQma3DsDyqcwE0DAuJJ/hGj5fuIwDwWGeDg0v/60cifvwqvW07+Hgq5DCDw/ShUzRW1+TSjsoFibHOldWJ9UK1KXBdhUzhDyEpbE0D21xRHpm9tBVVgfVo6q7Z6E6idUW1mXFaMHva6n+DntlVENQ1sQ40JO6DsxULBzV4Aj+4+ebhImfFtYW4r4oHGc+vhnVWLRYUYvnPJkBI16wYpnUwBBEGAmuq9v92y0hYq+DwrvVQjln10zaysxU3/P9bJngXAKYTWJ9prr6jNA== X-MS-Exchange-CrossTenant-OriginalArrivalTime: 22 May 2017 09:40:01.9318 (UTC) X-MS-Exchange-CrossTenant-Id: 5afe0b00-7697-4969-b663-5eab37d5f47e X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=5afe0b00-7697-4969-b663-5eab37d5f47e; Ip=[192.88.168.50]; Helo=[tx30smr01.am.freescale.net] X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: DM2PR0301MB0912 Subject: [dpdk-dev] [PATCH v3 08/20] net/dpaa2: add support for congestion notification X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 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" In case of HW egress FQ is congested, skip further transmission of frames. Signed-off-by: Hemant Agrawal --- drivers/bus/fslmc/portal/dpaa2_hw_pvt.h | 5 +- drivers/net/dpaa2/dpaa2_ethdev.c | 62 ++++++++++++++- drivers/net/dpaa2/dpaa2_ethdev.h | 14 ++++ drivers/net/dpaa2/dpaa2_rxtx.c | 4 + drivers/net/dpaa2/mc/dpni.c | 47 ++++++++++++ drivers/net/dpaa2/mc/fsl_dpni.h | 129 +++++++++++++++++++++++++++++++- drivers/net/dpaa2/mc/fsl_dpni_cmd.h | 36 +++++++++ 7 files changed, 289 insertions(+), 8 deletions(-) diff --git a/drivers/bus/fslmc/portal/dpaa2_hw_pvt.h b/drivers/bus/fslmc/portal/dpaa2_hw_pvt.h index e04edc6..b83ddd9 100644 --- a/drivers/bus/fslmc/portal/dpaa2_hw_pvt.h +++ b/drivers/bus/fslmc/portal/dpaa2_hw_pvt.h @@ -123,7 +123,10 @@ struct dpaa2_queue { uint64_t rx_pkts; uint64_t tx_pkts; uint64_t err_pkts; - struct queue_storage_info_t *q_storage; + union { + struct queue_storage_info_t *q_storage; + struct qbman_result *cscn; + }; }; struct swp_active_dqs { diff --git a/drivers/net/dpaa2/dpaa2_ethdev.c b/drivers/net/dpaa2/dpaa2_ethdev.c index 797e71d..80f1cd7 100644 --- a/drivers/net/dpaa2/dpaa2_ethdev.c +++ b/drivers/net/dpaa2/dpaa2_ethdev.c @@ -177,8 +177,13 @@ for (i = 0; i < priv->nb_tx_queues; i++) { mc_q->dev = dev; - mc_q->flow_id = DPNI_NEW_FLOW_ID; + mc_q->flow_id = 0xffff; priv->tx_vq[i] = mc_q++; + dpaa2_q = (struct dpaa2_queue *)priv->tx_vq[i]; + dpaa2_q->cscn = rte_malloc(NULL, + sizeof(struct qbman_result), 16); + if (!dpaa2_q->cscn) + goto fail_tx; } vq_id = 0; @@ -191,6 +196,14 @@ } return 0; +fail_tx: + i -= 1; + while (i >= 0) { + dpaa2_q = (struct dpaa2_queue *)priv->tx_vq[i]; + rte_free(dpaa2_q->cscn); + priv->tx_vq[i--] = NULL; + } + i = priv->nb_rx_queues; fail: i -= 1; mc_q = priv->rx_vq[0]; @@ -320,7 +333,7 @@ PMD_INIT_FUNC_TRACE(); /* Return if queue already configured */ - if (dpaa2_q->flow_id != DPNI_NEW_FLOW_ID) + if (dpaa2_q->flow_id != 0xffff) return 0; memset(&tx_conf_cfg, 0, sizeof(struct dpni_queue)); @@ -358,6 +371,36 @@ } dpaa2_q->tc_index = tc_id; + if (priv->flags & DPAA2_TX_CGR_SUPPORT) { + struct dpni_congestion_notification_cfg cong_notif_cfg; + + cong_notif_cfg.units = DPNI_CONGESTION_UNIT_BYTES; + /* Notify about congestion when the queue size is 32 KB */ + cong_notif_cfg.threshold_entry = CONG_ENTER_TX_THRESHOLD; + /* Notify that the queue is not congested when the data in + * the queue is below this thershold. + */ + cong_notif_cfg.threshold_exit = CONG_EXIT_TX_THRESHOLD; + cong_notif_cfg.message_ctx = 0; + cong_notif_cfg.message_iova = (uint64_t)dpaa2_q->cscn; + cong_notif_cfg.dest_cfg.dest_type = DPNI_DEST_NONE; + cong_notif_cfg.notification_mode = + DPNI_CONG_OPT_WRITE_MEM_ON_ENTER | + DPNI_CONG_OPT_WRITE_MEM_ON_EXIT | + DPNI_CONG_OPT_COHERENT_WRITE; + + ret = dpni_set_congestion_notification(dpni, CMD_PRI_LOW, + priv->token, + DPNI_QUEUE_TX, + tc_id, + &cong_notif_cfg); + if (ret) { + PMD_INIT_LOG(ERR, + "Error in setting tx congestion notification: = %d", + -ret); + return -ret; + } + } dev->data->tx_queues[tx_queue_id] = dpaa2_q; return 0; } @@ -513,12 +556,22 @@ static void dpaa2_dev_close(struct rte_eth_dev *dev) { + struct rte_eth_dev_data *data = dev->data; struct dpaa2_dev_priv *priv = dev->data->dev_private; struct fsl_mc_io *dpni = (struct fsl_mc_io *)priv->hw; - int ret; + int i, ret; + struct dpaa2_queue *dpaa2_q; PMD_INIT_FUNC_TRACE(); + for (i = 0; i < data->nb_tx_queues; i++) { + dpaa2_q = (struct dpaa2_queue *)data->tx_queues[i]; + if (!dpaa2_q->cscn) { + rte_free(dpaa2_q->cscn); + dpaa2_q->cscn = NULL; + } + } + /* Clean the device first */ ret = dpni_reset(dpni, CMD_PRI_LOW, priv->token); if (ret) { @@ -832,6 +885,9 @@ void dpaa2_dev_stats_reset(struct rte_eth_dev *dev) priv->max_vlan_filters = attr.vlan_filter_entries; priv->flags = 0; + priv->flags |= DPAA2_TX_CGR_SUPPORT; + PMD_INIT_LOG(INFO, "Enable the tx congestion control support"); + /* Allocate memory for hardware structure for queues */ ret = dpaa2_alloc_rx_tx_queues(eth_dev); if (ret) { diff --git a/drivers/net/dpaa2/dpaa2_ethdev.h b/drivers/net/dpaa2/dpaa2_ethdev.h index 7fa7e7d..e7728ba 100644 --- a/drivers/net/dpaa2/dpaa2_ethdev.h +++ b/drivers/net/dpaa2/dpaa2_ethdev.h @@ -47,9 +47,23 @@ /*default tc to be used for ,congestion, distribution etc configuration. */ #define DPAA2_DEF_TC 0 +/* Threshold for a queue to *Enter* Congestion state. + * It is set to 32KB + */ +#define CONG_ENTER_TX_THRESHOLD (32 * 1024) + +/* Threshold for a queue to *Exit* Congestion state. + */ +#define CONG_EXIT_TX_THRESHOLD (24 * 1024) + /* Size of the input SMMU mapped memory required by MC */ #define DIST_PARAM_IOVA_SIZE 256 +/* Enable TX Congestion control support + * default is disable + */ +#define DPAA2_TX_CGR_SUPPORT 0x01 + struct dpaa2_dev_priv { void *hw; int32_t hw_id; diff --git a/drivers/net/dpaa2/dpaa2_rxtx.c b/drivers/net/dpaa2/dpaa2_rxtx.c index 9b7539a..0670ae3 100644 --- a/drivers/net/dpaa2/dpaa2_rxtx.c +++ b/drivers/net/dpaa2/dpaa2_rxtx.c @@ -406,6 +406,10 @@ static inline int __attribute__((hot)) /*Clear the unused FD fields before sending*/ while (nb_pkts) { + /*Check if the queue is congested*/ + if (qbman_result_SCN_state_in_mem(dpaa2_q->cscn)) + goto skip_tx; + frames_to_send = (nb_pkts >> 3) ? MAX_TX_RING_SLOTS : nb_pkts; for (loop = 0; loop < frames_to_send; loop++) { diff --git a/drivers/net/dpaa2/mc/dpni.c b/drivers/net/dpaa2/mc/dpni.c index 3330614..145336d 100644 --- a/drivers/net/dpaa2/mc/dpni.c +++ b/drivers/net/dpaa2/mc/dpni.c @@ -626,6 +626,53 @@ int dpni_set_tx_confirmation_mode(struct fsl_mc_io *mc_io, return mc_send_command(mc_io, &cmd); } +int dpni_set_congestion_notification(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + enum dpni_queue_type qtype, + uint8_t tc_id, + const struct dpni_congestion_notification_cfg *cfg) +{ + struct mc_command cmd = { 0 }; + + /* prepare command */ + cmd.header = mc_encode_cmd_header( + DPNI_CMDID_SET_CONGESTION_NOTIFICATION, + cmd_flags, + token); + DPNI_CMD_SET_CONGESTION_NOTIFICATION(cmd, qtype, tc_id, cfg); + + /* send command to mc*/ + return mc_send_command(mc_io, &cmd); +} + +int dpni_get_congestion_notification(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + enum dpni_queue_type qtype, + uint8_t tc_id, + struct dpni_congestion_notification_cfg *cfg) +{ + struct mc_command cmd = { 0 }; + int err; + + /* prepare command */ + cmd.header = mc_encode_cmd_header( + DPNI_CMDID_GET_CONGESTION_NOTIFICATION, + cmd_flags, + token); + DPNI_CMD_GET_CONGESTION_NOTIFICATION(cmd, qtype, tc_id); + + /* send command to mc*/ + err = mc_send_command(mc_io, &cmd); + if (err) + return err; + + DPNI_RSP_GET_CONGESTION_NOTIFICATION(cmd, cfg); + + return 0; +} + int dpni_get_api_version(struct fsl_mc_io *mc_io, uint32_t cmd_flags, uint16_t *major_ver, diff --git a/drivers/net/dpaa2/mc/fsl_dpni.h b/drivers/net/dpaa2/mc/fsl_dpni.h index ef14f85..10dccc7 100644 --- a/drivers/net/dpaa2/mc/fsl_dpni.h +++ b/drivers/net/dpaa2/mc/fsl_dpni.h @@ -72,10 +72,7 @@ * All flows within traffic class considered; see dpni_set_queue() */ #define DPNI_ALL_TC_FLOWS (uint16_t)(-1) -/** - * Generate new flow ID; see dpni_set_queue() - */ -#define DPNI_NEW_FLOW_ID (uint16_t)(-1) + /** * Tx traffic is always released to a buffer pool on transmit, there are no * resources allocated to have the frames confirmed back to the source after @@ -961,6 +958,16 @@ int dpni_set_rx_tc_dist(struct fsl_mc_io *mc_io, uint16_t token, uint8_t tc_id, const struct dpni_rx_tc_dist_cfg *cfg); +/** + * enum dpni_congestion_unit - DPNI congestion units + * @DPNI_CONGESTION_UNIT_BYTES: bytes units + * @DPNI_CONGESTION_UNIT_FRAMES: frames units + */ +enum dpni_congestion_unit { + DPNI_CONGESTION_UNIT_BYTES = 0, + DPNI_CONGESTION_UNIT_FRAMES +}; + /** * enum dpni_dest - DPNI destination types @@ -981,6 +988,118 @@ enum dpni_dest { DPNI_DEST_DPCON = 2 }; +/** + * struct dpni_dest_cfg - Structure representing DPNI destination parameters + * @dest_type: Destination type + * @dest_id: Either DPIO ID or DPCON ID, depending on the destination type + * @priority: Priority selection within the DPIO or DPCON channel; valid values + * are 0-1 or 0-7, depending on the number of priorities in that + * channel; not relevant for 'DPNI_DEST_NONE' option + */ +struct dpni_dest_cfg { + enum dpni_dest dest_type; + int dest_id; + uint8_t priority; +}; + +/* DPNI congestion options */ + +/** + * CSCN message is written to message_iova once entering a + * congestion state (see 'threshold_entry') + */ +#define DPNI_CONG_OPT_WRITE_MEM_ON_ENTER 0x00000001 +/** + * CSCN message is written to message_iova once exiting a + * congestion state (see 'threshold_exit') + */ +#define DPNI_CONG_OPT_WRITE_MEM_ON_EXIT 0x00000002 +/** + * CSCN write will attempt to allocate into a cache (coherent write); + * valid only if 'DPNI_CONG_OPT_WRITE_MEM_' is selected + */ +#define DPNI_CONG_OPT_COHERENT_WRITE 0x00000004 +/** + * if 'dest_cfg.dest_type != DPNI_DEST_NONE' CSCN message is sent to + * DPIO/DPCON's WQ channel once entering a congestion state + * (see 'threshold_entry') + */ +#define DPNI_CONG_OPT_NOTIFY_DEST_ON_ENTER 0x00000008 +/** + * if 'dest_cfg.dest_type != DPNI_DEST_NONE' CSCN message is sent to + * DPIO/DPCON's WQ channel once exiting a congestion state + * (see 'threshold_exit') + */ +#define DPNI_CONG_OPT_NOTIFY_DEST_ON_EXIT 0x00000010 +/** + * if 'dest_cfg.dest_type != DPNI_DEST_NONE' when the CSCN is written to the + * sw-portal's DQRR, the DQRI interrupt is asserted immediately (if enabled) + */ +#define DPNI_CONG_OPT_INTR_COALESCING_DISABLED 0x00000020 + +/** + * struct dpni_congestion_notification_cfg - congestion notification + * configuration + * @units: units type + * @threshold_entry: above this threshold we enter a congestion state. + * set it to '0' to disable it + * @threshold_exit: below this threshold we exit the congestion state. + * @message_ctx: The context that will be part of the CSCN message + * @message_iova: I/O virtual address (must be in DMA-able memory), + * must be 16B aligned; valid only if 'DPNI_CONG_OPT_WRITE_MEM_' is + * contained in 'options' + * @dest_cfg: CSCN can be send to either DPIO or DPCON WQ channel + * @notification_mode: Mask of available options; use 'DPNI_CONG_OPT_' values + */ + +struct dpni_congestion_notification_cfg { + enum dpni_congestion_unit units; + uint32_t threshold_entry; + uint32_t threshold_exit; + uint64_t message_ctx; + uint64_t message_iova; + struct dpni_dest_cfg dest_cfg; + uint16_t notification_mode; +}; + +/** + * dpni_set_congestion_notification() - Set traffic class congestion + * notification configuration + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPNI object + * @qtype: Type of queue - Rx, Tx and Tx confirm types are supported + * @tc_id: Traffic class selection (0-7) + * @cfg: congestion notification configuration + * + * Return: '0' on Success; error code otherwise. + */ +int dpni_set_congestion_notification(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + enum dpni_queue_type qtype, + uint8_t tc_id, + const struct dpni_congestion_notification_cfg *cfg); + +/** + * dpni_get_congestion_notification() - Get traffic class congestion + * notification configuration + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPNI object + * @qtype: Type of queue - Rx, Tx and Tx confirm types are supported + * @tc_id: Traffic class selection (0-7) + * @cfg: congestion notification configuration + * + * Return: '0' on Success; error code otherwise. + */ +int dpni_get_congestion_notification(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + enum dpni_queue_type qtype, + uint8_t tc_id, + struct dpni_congestion_notification_cfg *cfg); + /** * struct dpni_queue - Queue structure @@ -1077,6 +1196,8 @@ enum dpni_confirmation_mode { * Calling this function with 'mode' set to DPNI_CONF_SINGLE switches all * Tx confirmations to a shared Tx conf queue. The ID of the queue when * calling dpni_set/get_queue is -1. + * Tx confirmation mode can only be changed while the DPNI is disabled. + * Executing this command while the DPNI is enabled will return an error. * * Return: '0' on Success; Error code otherwise. */ diff --git a/drivers/net/dpaa2/mc/fsl_dpni_cmd.h b/drivers/net/dpaa2/mc/fsl_dpni_cmd.h index bb92ea8..383649e 100644 --- a/drivers/net/dpaa2/mc/fsl_dpni_cmd.h +++ b/drivers/net/dpaa2/mc/fsl_dpni_cmd.h @@ -82,6 +82,8 @@ #define DPNI_CMDID_GET_BUFFER_LAYOUT ((0x264 << 4) | (0x1)) #define DPNI_CMDID_SET_BUFFER_LAYOUT ((0x265 << 4) | (0x1)) +#define DPNI_CMDID_SET_CONGESTION_NOTIFICATION ((0x267 << 4) | (0x1)) +#define DPNI_CMDID_GET_CONGESTION_NOTIFICATION ((0x268 << 4) | (0x1)) #define DPNI_CMDID_GET_OFFLOAD ((0x26B << 4) | (0x1)) #define DPNI_CMDID_SET_OFFLOAD ((0x26C << 4) | (0x1)) #define DPNI_CMDID_SET_TX_CONFIRMATION_MODE ((0x266 << 4) | (0x1)) @@ -331,4 +333,38 @@ #define DPNI_RSP_GET_TX_CONFIRMATION_MODE(cmd, mode) \ MC_RSP_OP(cmd, 0, 32, 8, enum dpni_confirmation_mode, mode) +#define DPNI_CMD_SET_CONGESTION_NOTIFICATION(cmd, qtype, tc, cfg) \ +do { \ + MC_CMD_OP(cmd, 0, 0, 8, enum dpni_queue_type, qtype); \ + MC_CMD_OP(cmd, 0, 8, 8, uint8_t, tc); \ + MC_CMD_OP(cmd, 1, 0, 32, uint32_t, (cfg)->dest_cfg.dest_id); \ + MC_CMD_OP(cmd, 1, 32, 16, uint16_t, (cfg)->notification_mode); \ + MC_CMD_OP(cmd, 1, 48, 8, uint8_t, (cfg)->dest_cfg.priority); \ + MC_CMD_OP(cmd, 1, 56, 4, enum dpni_dest, (cfg)->dest_cfg.dest_type); \ + MC_CMD_OP(cmd, 1, 60, 2, enum dpni_congestion_unit, (cfg)->units); \ + MC_CMD_OP(cmd, 2, 0, 64, uint64_t, (cfg)->message_iova); \ + MC_CMD_OP(cmd, 3, 0, 64, uint64_t, (cfg)->message_ctx); \ + MC_CMD_OP(cmd, 4, 0, 32, uint32_t, (cfg)->threshold_entry); \ + MC_CMD_OP(cmd, 4, 32, 32, uint32_t, (cfg)->threshold_exit); \ +} while (0) + +#define DPNI_CMD_GET_CONGESTION_NOTIFICATION(cmd, qtype, tc) \ +do { \ + MC_CMD_OP(cmd, 0, 0, 8, enum dpni_queue_type, qtype); \ + MC_CMD_OP(cmd, 0, 8, 8, uint8_t, tc); \ +} while (0) + +#define DPNI_RSP_GET_CONGESTION_NOTIFICATION(cmd, cfg) \ +do { \ + MC_RSP_OP(cmd, 1, 0, 32, uint32_t, (cfg)->dest_cfg.dest_id); \ + MC_RSP_OP(cmd, 1, 0, 16, uint16_t, (cfg)->notification_mode); \ + MC_RSP_OP(cmd, 1, 48, 8, uint8_t, (cfg)->dest_cfg.priority); \ + MC_RSP_OP(cmd, 1, 56, 4, enum dpni_dest, (cfg)->dest_cfg.dest_type); \ + MC_RSP_OP(cmd, 1, 60, 2, enum dpni_congestion_unit, (cfg)->units); \ + MC_RSP_OP(cmd, 2, 0, 64, uint64_t, (cfg)->message_iova); \ + MC_RSP_OP(cmd, 3, 0, 64, uint64_t, (cfg)->message_ctx); \ + MC_RSP_OP(cmd, 4, 0, 32, uint32_t, (cfg)->threshold_entry); \ + MC_RSP_OP(cmd, 4, 32, 32, uint32_t, (cfg)->threshold_exit); \ +} while (0) + #endif /* _FSL_DPNI_CMD_H */