From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from NAM03-DM3-obe.outbound.protection.outlook.com (mail-dm3nam03on0059.outbound.protection.outlook.com [104.47.41.59]) by dpdk.org (Postfix) with ESMTP id 5A8A999C6 for ; Thu, 25 May 2017 20:08:50 +0200 (CEST) Received: from BN3PR03CA0053.namprd03.prod.outlook.com (10.167.1.141) by BY2PR03MB173.namprd03.prod.outlook.com (10.242.36.139) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1101.14; Thu, 25 May 2017 18:08:47 +0000 Received: from BN1BFFO11FD006.protection.gbl (2a01:111:f400:7c10::1:113) by BN3PR03CA0053.outlook.office365.com (2a01:111:e400:7a4d::13) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1124.9 via Frontend Transport; Thu, 25 May 2017 18:08:47 +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 BN1BFFO11FD006.mail.protection.outlook.com (10.58.144.69) with Microsoft SMTP Server (version=TLS1_0, cipher=TLS_RSA_WITH_AES_256_CBC_SHA) id 15.1.1075.5 via Frontend Transport; Thu, 25 May 2017 18:08:46 +0000 Received: from b27504-OptiPlex-790.ap.freescale.net (b27504-OptiPlex-790.ap.freescale.net [10.232.132.60]) by tx30smr01.am.freescale.net (8.14.3/8.14.0) with ESMTP id v4PI84WF022340; Thu, 25 May 2017 11:08:43 -0700 From: Nipun Gupta To: CC: , , , , , , Nipun Gupta Date: Thu, 25 May 2017 23:37:35 +0530 Message-ID: <1495735671-4917-5-git-send-email-nipun.gupta@nxp.com> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1495735671-4917-1-git-send-email-nipun.gupta@nxp.com> References: <1495735671-4917-1-git-send-email-nipun.gupta@nxp.com> X-EOPAttributedMessage: 0 X-Matching-Connectors: 131402093270905682; (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)(39410400002)(39400400002)(39850400002)(39860400002)(39840400002)(39380400002)(39450400003)(2980300002)(1110001)(1109001)(339900001)(199003)(189002)(9170700003)(498600001)(81166006)(8676002)(47776003)(48376002)(8936002)(36756003)(5660300001)(50986999)(76176999)(50466002)(2351001)(189998001)(305945005)(356003)(105606002)(33646002)(106466001)(50226002)(86362001)(77096006)(54906002)(4326008)(104016004)(53936002)(85426001)(2906002)(38730400002)(6666003)(110136004)(2950100002)(8656002)(6916009)(5003940100001)(2004002); DIR:OUT; SFP:1101; SCL:1; SRVR:BY2PR03MB173; H:tx30smr01.am.freescale.net; FPR:; SPF:Fail; MLV:ovrnspm; A:1; MX:1; PTR:InfoDomainNonexistent; LANG:en; X-Microsoft-Exchange-Diagnostics: 1; BN1BFFO11FD006; 1:XnXav0Kh1WY0GhyGD3Wg9lDL5TozyHGCRRCmXHTh/Nu0MFRDXhY12hCrGjxF8z7bQhqup9rfxY/iY6CGLof3RU1X+q9vuvYIRIWEDY3/8WdfC3hfBARKKe0CS8HqkAiS+4kCPe88MQLiqilyDeIU5eQamADR1EfDVftV9nhllWYyZcvT2RULsCB3Vwo67xxwJFwPVScKABt+2QAdSm0MUilmYSavLr0+HiOlOdLnbSzp73JDZXFtGdcuf4rafaeo1wsy2NAfywahLwu3ksS9e8MYHoaBVfDEVdmKPXlniuY4KM/9/NjGa6NJVyXvCsghKIYj7yldoJMgKyquLj463gtnH+yPAseZs027Kio1SsEXkO5qaqQGqomPJcZHrfBj8jHeOLVmXbqJPJDRHi9hNBjAUPgvsRcOo9lapA+vNUCWH176i3RR5TQYr64WA6JAFjUmarOwAcWLLw16nrC7rgutEf8/kC2omVJgiv7+WSJqpAFLuUNp28/ny+6CwQSMTfuBBF80/LxKQnuZbqivJsUsGUGZP94/Vy9DEmU6Vs4Q3yxIAYYpcVvMpZMvjAq2iQtSFIZ4sIxh7H+HZipWTrkikKtj2ZcHCmwv7sTRIf4yrycGxM0e2GeGKJX+jG1cOLhEK/OrKxBv7kLTvqV8r3wADy7ETY7kFtSvIRSTUPOjdqc/Q9A4+cDVX4L+NdqQMJpojUOk5Gsfcmp+PdKGOA== MIME-Version: 1.0 Content-Type: text/plain X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: BY2PR03MB173: X-MS-Office365-Filtering-Correlation-Id: 576a4fa8-faf6-41db-51f3-08d4a399169c X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(22001)(201703131430075)(201703131517081); SRVR:BY2PR03MB173; X-Microsoft-Exchange-Diagnostics: 1; BY2PR03MB173; 3:l5eQ1DcAMFKH9KCKmybZfqokruNwvHuo1GGTWJ84A4Uu2sBR+P+KyaoYTJqSsSbzFuPVU0gX6tpDAThljwY2g9kqnn0WE7tmik8lV3EMwDuoaYxgq69Fpboclvq2ruixWLLzHhc92/aGgE1F2BpmZTNK2SdoU6eeB4QowV8L+Xe1l8mz98ZvFpbHoeWbaRC4jbWwnTd5qDde5EPZqfQ0n786XLbaErgF7PRILlSs/uVWLGFwqZJU5baqN1FKTa40p5Lolqu1NM6X5Vi2KJvu09ySyWeitJ4OsxsAUGcuS50TbjbMqxwzksXOzhRzb/yTD7ua+LxMJtUfZwUB0Hv/FNPQuh1Z9Hgn1ieGJ+J8+cQhNBlsV9+ch7DBVUNm416xfaFvaItiZsrZ5GYiNYJlp5Nw4WVgsohZ87McuWHBMshi9zEht1N59EndpV8wdHBP; 25:Tp727RkbKKEtk6z/flhx1zVNd5FKQ8i94kaX3GvVyk+bSjyDnVCMo/t72H+YCslCsZXDL8HEjqqyFD/c3ilGIzM4ok5V31oaOyaMkvBXyppEXzpeJ2mvYo2hwHS5W4ttUpytzQctnS+nniCYN6pKT+Coboey1cgz2pUSLTlKlbh2M1DNMMqRUrmKxtMrMCTxxRrLOJ3GSPg50L2hpxA1ka1K8dpKvBNWEM7FoYKKaHfVWWDMhm7BIka3PRw5vtRY9Ih/KrTdufuKcFj59yLJxGqE6aKdyj4Uppt+e6H49PQh4b45NmIVf6HjK4FmgLChYBAl0bBxvwlX1rRJBG000wodV4Etqi+Ae8pTiUr++gaPrEs6RHz74kyu0QrWi3J6r9a8PkFvkkvW2ZoqijHyxMyDjmFfDWvGv67NhrZJjpsd/sJ1H8WyJt0qNRhQYAR3H1V5XIPWbylw6p9qIdr+GUIorUtgi6tAI/Mf8rBH5nw= X-Microsoft-Exchange-Diagnostics: 1; BY2PR03MB173; 31:Rv2BHAs/ZMAs0uQkzjQn1wplmi/O5k+u9hTRxX81ljpPBn3wgR+dPRtZNZoOXfF0jEiC8VdgrrFN+0Txb7PYpFVp9AEn/x76RQuGT4TRyi52a29pOU49CnU5BHkRHvUoL/DsmSa8GucBXtrdQts2uXkORYpq0+KKOydLin65N4qCJPB7L7uAH1rAYMDnRiV0VOLUbt05ZFalXhSMq9W3wrF5vw2I/9n8KtsCHNj0ez82Y3pwmABS3fRTHxlDHXuSkWbBUtFZUp3vNDwq3CFHyw== 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)(13016025)(5005006)(13018025)(8121501046)(10201501046)(3002001)(93006095)(93001095)(6055026)(6096035)(20161123561025)(201703131430075)(201703131433075)(201703131441075)(201703131448075)(201703161259150)(20161123556025)(20161123559100)(20161123565025)(20161123563025); SRVR:BY2PR03MB173; BCL:0; PCL:0; RULEID:(400006); SRVR:BY2PR03MB173; X-Microsoft-Exchange-Diagnostics: 1; BY2PR03MB173; 4:qbYfb8/a3ze3M4RjM3RHdy0U1FzKfjifKSJGWtHihAbAOyF1v0Nc5IB8PunTVSadaeKtyD+sMoY6EncDZzPs3CK70tE6lWLLbv8L3stU9r0BMPmoyKUP2l6qTUB7nIKaDl0pOa0VDpBf6Q3VugVVKMaarHkDdSDn/QtyIt1YL9XA3AHZhqfZz0kn7ge38ZUQzAchB89D2WkZtBkw+cU9r7GCS7OmVgn7aWD/pWIsGIOvcNyVg3e+3Sco24zO1xr0ThU1At/E5sG+0IMNJ0x15HPv2tU6ba68tleWgkjK32vxxjFlYvCegomcw7g6gyRQHeN+OC3ebodSJ78FeVRPzkqkQ4QvIYdhRGCoLpBE7Cuy0YdCUSSeVJZ8/1YeFJgw1ugGdUwdBX5hvGg5apgVDQ5NKy7pJvdewFgyUg+N2/HHRQT4hcVbVE31iC7vamuuiHL6+xC2mowHMs9QYEk9hKCmVqMwPapMnLLfFdnP/gMNgV6RkNyJhLWcRU64IDf1q9tw6JygncDjH+Tc287ddW/iOtdJpsgieE3rJZulC888P4Pszq4x0rsNuTK+Km7Lxjvxny+vuvVEbFdMvW6gh/74RFaGIttPBWppyWMAWP7/jPW+JVz5TEeE5wpcoAGBjFAV3cTSgZjt21aiMez8MyLiWOW7a3/xicFbO3vnTCzcqnYXAua4WPKD3mbJzr2wmp9pBxy2da/01d00UP8ATqYzi552O9TvnmJcUpVPvi8gTMumfSUsZGs5ofiCouP7KrOKdfL7U5c6mHi1O489sT4phhqFCfQKDEHk1JrAk24bYKOo9dINj1+IzA5WOxs4V4L0v/VemDpziObnpuo+pBWiCu8kuzqg8cQ6kNuQ1ntkxzk5ewrq4MyYFJjuzD1nMqAydLc+zWvMN4JxzLVDd52fv77+x6ZTTeppQQQx0iqyrkOVGIQqQHX0jP5kKN8i X-Forefront-PRVS: 0318501FAE X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; BY2PR03MB173; 23:X8qVd/DXgOqO1l7PR0NGN9fxILOoEa5rpw2o2gDgoW?= =?us-ascii?Q?1URN27ffHHOwoLx8rJlr59T4x1gf8TF7j8dYl+fBk5eRRF+XwTv4bpq5l3Kd?= =?us-ascii?Q?X76yY2kkCg0ufZXqDO4A2RufWSzKwNAmT78s4f0+jIyvMpvmZaLXUKOlVnPC?= =?us-ascii?Q?DXZxsI0ig0QdXUM+6cnZVZ2vz+VfAnjFOWrlsMuBtMfroO9xzEmI647JtAZV?= =?us-ascii?Q?xlL+e4NuG0wVyDEWUgacnRIW7MedUNfkagD7G89Od3ID0/cfe/Lda4mYfE6Y?= =?us-ascii?Q?4+K8lVbBYlQJHhdwD8mS7pbuW1HX8Mx78Iivqlb3Al7JlcrAliN0ViwIa+CH?= =?us-ascii?Q?DiAueFxmL256wd3Or3vN+JwLCuKVxKPjNk9MdzElKoBqSSDawyVC9BFYHszu?= =?us-ascii?Q?rclXT01K2yYLdtKVr9tlOErIhIH0bK/h1GDiu0fMYFWol61fYcGJWSgvVJhG?= =?us-ascii?Q?y5xqqzcqlMfN/7EwQ/C6bdfKxxa1EDOFWzrecVdqcJDLRA2v0I0AiXEtX5lq?= =?us-ascii?Q?p2qXd5mNScMpjbTOriBrNCOOkNF46VyAocrS3gm751TKXqIwM8wyF80FOyqo?= =?us-ascii?Q?JoHaGBotlnFTDqvC1j9QwtgBlxF+zH1xO+w9/gXOuyZE8D9glU5OuCH44Zuz?= =?us-ascii?Q?ySAfWgBNH9wyDa0KE8LoIswGBe93JR9X8LMVsXUUq1rvgtDjLA5Mn5QKCsxt?= =?us-ascii?Q?rObL5YXJH6p3/X9SVLEJ7SC0GfYGl/80/AQfBQCs3GscKldtwkjiddFBr0y9?= =?us-ascii?Q?02R2Lhz5RhPYuBsiFDIQJRSXgscSS9zK3UM+cRs9hM7TphvQYUw6RqB3XXSC?= =?us-ascii?Q?g0WM1HMh65RXxqx23Gx1YZcBQhp96oBxv9vj9D/Ut45VWJmavWfcmNGY2qkS?= =?us-ascii?Q?wulrCNZ3qg2xGXpKh7QwLifhvD3hVTJgVMmlA8kk9DVoBnmUEPEYDB/mVZ7e?= =?us-ascii?Q?YBC4NFXagTW7fx/VVQ9hef57aO56n7qLmawOMposul+CB4MTYugLzqlLzaq5?= =?us-ascii?Q?id8ow8cAkM7qf+SEvDUMxew7sAgG/95JlvvdmDqvqEZsTNLGKRPk14tf41+s?= =?us-ascii?Q?Sl7pTdpEgZoLZettZdgJbtL+zMQwwZTjwX0exqbnmqbMJGCv3TZRkBMuXEvm?= =?us-ascii?Q?sYvSOSyKjN9lhCpChk6v7lyVtdUwDx+zIpavfoCMQ34ayYtb1QNHK2q1b6oL?= =?us-ascii?Q?JdNHcFx+6K8z5xZZpF5iS8OApDoXbeTqgvmSMG9th1cmMuUwDfIk+i4QD4x9?= =?us-ascii?Q?NIJL3qWpGGlNYwqOY=3D?= X-Microsoft-Exchange-Diagnostics: 1; BY2PR03MB173; 6:Yonw8PRZn4iwHBLnH1Udil9Owx1AdBggTam8xu2efTVQ8a/9VKid1DeBELukLYIACZkKSaZwGKrWRsAr2MfVbto8Fp7lnVgcOvn9Nbyws4dwuL51MJQ00y032wMOeYWFm6319KH6vRF0ZjnrJ+xRnMMYrSElo2qMOCG+yVG1ZgUyLsxsalKlrdygNl5pSbh8Ja3PUNpiMdB/KGxrivJl+29SepF3d/Y/IUBd0+BeXTkgtTuPWHzMsQ1DsaTDmvOYD+BS0AjTQV7aBV4dZeAOmkYCjeX1Guyv0f4cW252uTL80H2XyJEH6Og4W89dvrmMKKIZXC2bu9kti+7TLMp5/CSVcC4ocJ6IBJNSNKSmPo8YH/TCtIHPKh793DsVRux7QXGEO4A7EcYjP5fygzdoqwov8d3Upy52jWT4lt5DtIig1QkPCq4qSKbHSn291JsLxrHas0JG7z3N48thzYVZRPU8nqCuxHtPHspTNCd7qP1QO0CyG6gkbmGBaRPtFrKPSv4KMS4RdXPqBzFmPgaP8w==; 5:yUZpm48gV41tiLt7tm2qez+qYDbau3V/gVno/BCoaQcd/He/ZLKNacgyx4HWfiIyKlGaDOXVefhOAwi3CdgEc7vhU+FMxP77FFOu8AHznSOrc1NfLbZZcsidy6dkFi+hcMN+HQlIQepDhEv7dHlCNIwoFxPv3tjFhkZVSXSD2Zrir7qfQQw24EmX0nlHlZ+q; 24:9E/Ra+rE8l6tXhrf2dUuyQGLlqo8hEhp0ojpl8/fNRhKgycDBYWpdyl9M+cajH5D3a3Q3c7s8ApFiGhlDGXH6oU8D2W/+cnEtLbSk8MBmeg= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; BY2PR03MB173; 7:G2c00Uw8E4XO2ysBUviK/dHVUZWmsd1i2YKSMalK2TjfBXjkd0cQ2r40WwpC5IdFunlqL0OCXpBgo7808m7lrjqQfUpxuaDqJn1R1mA7DPvPtvbhSPCVZLXp46qdJnTLBR9+6/D1wt4tAzfOX6CWrpnQXB+1hyNkhvbPoUkCvDw/QsHlyFHViB/z8NEEngZ5JJGVV0WfO9wIvj8X3WrlhqW1AVEZDkHFZAcUvD8rS0Q3jAKw/8aQh86eeSLWyirrUBNczjw9S/5CIZWGnFxLLq5f/XwFGbfsWcNmMU7OOXmqjvF4GPMZdt0HhuwMzwdLLw2fqNoioEzs8yTEz5IUkg== X-MS-Exchange-CrossTenant-OriginalArrivalTime: 25 May 2017 18:08:46.9033 (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: BY2PR03MB173 Subject: [dpdk-dev] [PATCH 04/20] bus/fslmc: adding basic dpcon support 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: , X-List-Received-Date: Thu, 25 May 2017 18:08:51 -0000 Signed-off-by: Nipun Gupta --- drivers/bus/fslmc/Makefile | 3 +- drivers/bus/fslmc/fslmc_vfio.h | 1 + drivers/bus/fslmc/mc/dpcon.c | 230 +++++++++++++++++++++++++++ drivers/bus/fslmc/mc/fsl_dpcon.h | 238 ++++++++++++++++++++++++++++ drivers/bus/fslmc/mc/fsl_dpcon_cmd.h | 175 ++++++++++++++++++++ drivers/bus/fslmc/rte_bus_fslmc_version.map | 2 + 6 files changed, 648 insertions(+), 1 deletion(-) create mode 100644 drivers/bus/fslmc/mc/dpcon.c create mode 100644 drivers/bus/fslmc/mc/fsl_dpcon.h create mode 100644 drivers/bus/fslmc/mc/fsl_dpcon_cmd.h diff --git a/drivers/bus/fslmc/Makefile b/drivers/bus/fslmc/Makefile index 973d279..7ef805b 100644 --- a/drivers/bus/fslmc/Makefile +++ b/drivers/bus/fslmc/Makefile @@ -65,7 +65,8 @@ SRCS-$(CONFIG_RTE_LIBRTE_FSLMC_BUS) += \ SRCS-$(CONFIG_RTE_LIBRTE_FSLMC_BUS) += \ mc/dpbp.c \ mc/dpio.c \ - mc/mc_sys.c + mc/mc_sys.c \ + mc/dpcon.c \ SRCS-$(CONFIG_RTE_LIBRTE_FSLMC_BUS) += portal/dpaa2_hw_dpio.c SRCS-$(CONFIG_RTE_LIBRTE_FSLMC_BUS) += portal/dpaa2_hw_dpbp.c diff --git a/drivers/bus/fslmc/fslmc_vfio.h b/drivers/bus/fslmc/fslmc_vfio.h index ffed62e..eddce31 100644 --- a/drivers/bus/fslmc/fslmc_vfio.h +++ b/drivers/bus/fslmc/fslmc_vfio.h @@ -39,6 +39,7 @@ #define DPAA2_VENDOR_ID 0x1957 #define DPAA2_MC_DPNI_DEVID 7 #define DPAA2_MC_DPSECI_DEVID 3 +#define DPAA2_MC_DPCON_DEVID 5 #define DPAA2_MC_DPIO_DEVID 9 #define DPAA2_MC_DPBP_DEVID 10 diff --git a/drivers/bus/fslmc/mc/dpcon.c b/drivers/bus/fslmc/mc/dpcon.c new file mode 100644 index 0000000..b078dff --- /dev/null +++ b/drivers/bus/fslmc/mc/dpcon.c @@ -0,0 +1,230 @@ +/* Copyright 2013-2016 Freescale Semiconductor Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the above-listed copyright holders nor the + * names of any contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * GNU General Public License ("GPL") as published by the Free Software + * Foundation, either version 2 of that License or (at your option) any + * later version. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ +#include +#include +#include +#include + +int dpcon_open(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + int dpcon_id, + uint16_t *token) +{ + struct mc_command cmd = { 0 }; + int err; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPCON_CMDID_OPEN, + cmd_flags, + 0); + DPCON_CMD_OPEN(cmd, dpcon_id); + + /* send command to mc*/ + err = mc_send_command(mc_io, &cmd); + if (err) + return err; + + /* retrieve response parameters */ + *token = MC_CMD_HDR_READ_TOKEN(cmd.header); + + return 0; +} + +int dpcon_close(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token) +{ + struct mc_command cmd = { 0 }; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPCON_CMDID_CLOSE, + cmd_flags, + token); + + /* send command to mc*/ + return mc_send_command(mc_io, &cmd); +} + +int dpcon_create(struct fsl_mc_io *mc_io, + uint16_t dprc_token, + uint32_t cmd_flags, + const struct dpcon_cfg *cfg, + uint32_t *obj_id) +{ + struct mc_command cmd = { 0 }; + int err; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPCON_CMDID_CREATE, + cmd_flags, + dprc_token); + DPCON_CMD_CREATE(cmd, cfg); + + /* send command to mc*/ + err = mc_send_command(mc_io, &cmd); + if (err) + return err; + + /* retrieve response parameters */ + CMD_CREATE_RSP_GET_OBJ_ID_PARAM0(cmd, *obj_id); + + return 0; +} + +int dpcon_destroy(struct fsl_mc_io *mc_io, + uint16_t dprc_token, + uint32_t cmd_flags, + uint32_t object_id) +{ + struct mc_command cmd = { 0 }; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPCON_CMDID_DESTROY, + cmd_flags, + dprc_token); + /* set object id to destroy */ + CMD_DESTROY_SET_OBJ_ID_PARAM0(cmd, object_id); + /* send command to mc*/ + return mc_send_command(mc_io, &cmd); +} + +int dpcon_enable(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token) +{ + struct mc_command cmd = { 0 }; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPCON_CMDID_ENABLE, + cmd_flags, + token); + + /* send command to mc*/ + return mc_send_command(mc_io, &cmd); +} + +int dpcon_disable(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token) +{ + struct mc_command cmd = { 0 }; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPCON_CMDID_DISABLE, + cmd_flags, + token); + + /* send command to mc*/ + return mc_send_command(mc_io, &cmd); +} + +int dpcon_is_enabled(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + int *en) +{ + struct mc_command cmd = { 0 }; + int err; + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPCON_CMDID_IS_ENABLED, + cmd_flags, + token); + + /* send command to mc*/ + err = mc_send_command(mc_io, &cmd); + if (err) + return err; + + /* retrieve response parameters */ + DPCON_RSP_IS_ENABLED(cmd, *en); + + return 0; +} + +int dpcon_reset(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token) +{ + struct mc_command cmd = { 0 }; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPCON_CMDID_RESET, + cmd_flags, token); + + /* send command to mc*/ + return mc_send_command(mc_io, &cmd); +} + +int dpcon_get_attributes(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + struct dpcon_attr *attr) +{ + struct mc_command cmd = { 0 }; + int err; + + /* prepare command */ + cmd.header = mc_encode_cmd_header(DPCON_CMDID_GET_ATTR, + cmd_flags, + token); + + /* send command to mc*/ + err = mc_send_command(mc_io, &cmd); + if (err) + return err; + + /* retrieve response parameters */ + DPCON_RSP_GET_ATTR(cmd, attr); + + return 0; +} + +int dpcon_get_api_version(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t *major_ver, + uint16_t *minor_ver) +{ + struct mc_command cmd = { 0 }; + int err; + + cmd.header = mc_encode_cmd_header(DPCON_CMDID_GET_API_VERSION, + cmd_flags, + 0); + + err = mc_send_command(mc_io, &cmd); + if (err) + return err; + + DPCON_RSP_GET_API_VERSION(cmd, *major_ver, *minor_ver); + + return 0; +} diff --git a/drivers/bus/fslmc/mc/fsl_dpcon.h b/drivers/bus/fslmc/mc/fsl_dpcon.h new file mode 100644 index 0000000..0ed9db5 --- /dev/null +++ b/drivers/bus/fslmc/mc/fsl_dpcon.h @@ -0,0 +1,238 @@ +/*- + * This file is provided under a dual BSD/GPLv2 license. When using or + * redistributing this file, you may do so under either license. + * + * BSD LICENSE + * + * Copyright 2013-2016 Freescale Semiconductor Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the above-listed copyright holders nor the + * names of any contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * GPL LICENSE SUMMARY + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * GNU General Public License ("GPL") as published by the Free Software + * Foundation, either version 2 of that License or (at your option) any + * later version. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef __FSL_DPCON_H +#define __FSL_DPCON_H + +/* Data Path Concentrator API + * Contains initialization APIs and runtime control APIs for DPCON + */ + +struct fsl_mc_io; + +/** General DPCON macros */ + +/** + * Use it to disable notifications; see dpcon_set_notification() + */ +#define DPCON_INVALID_DPIO_ID (int)(-1) + +/** + * dpcon_open() - Open a control session for the specified object + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @dpcon_id: DPCON unique ID + * @token: Returned token; use in subsequent API calls + * + * This function can be used to open a control session for an + * already created object; an object may have been declared in + * the DPL or by calling the dpcon_create() function. + * This function returns a unique authentication token, + * associated with the specific object ID and the specific MC + * portal; this token must be used in all subsequent commands for + * this specific object. + * + * Return: '0' on Success; Error code otherwise. + */ +int dpcon_open(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + int dpcon_id, + uint16_t *token); + +/** + * dpcon_close() - Close the control session of the object + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPCON object + * + * After this function is called, no further operations are + * allowed on the object without opening a new control session. + * + * Return: '0' on Success; Error code otherwise. + */ +int dpcon_close(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token); + +/** + * struct dpcon_cfg - Structure representing DPCON configuration + * @num_priorities: Number of priorities for the DPCON channel (1-8) + */ +struct dpcon_cfg { + uint8_t num_priorities; +}; + +/** + * dpcon_create() - Create the DPCON object. + * @mc_io: Pointer to MC portal's I/O object + * @dprc_token: Parent container token; '0' for default container + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @cfg: Configuration structure + * @obj_id: returned object id + * + * Create the DPCON object, allocate required resources and + * perform required initialization. + * + * The object can be created either by declaring it in the + * DPL file, or by calling this function. + * + * The function accepts an authentication token of a parent + * container that this object should be assigned to. The token + * can be '0' so the object will be assigned to the default container. + * The newly created object can be opened with the returned + * object id and using the container's associated tokens and MC portals. + * + * Return: '0' on Success; Error code otherwise. + */ +int dpcon_create(struct fsl_mc_io *mc_io, + uint16_t dprc_token, + uint32_t cmd_flags, + const struct dpcon_cfg *cfg, + uint32_t *obj_id); + +/** + * dpcon_destroy() - Destroy the DPCON object and release all its resources. + * @mc_io: Pointer to MC portal's I/O object + * @dprc_token: Parent container token; '0' for default container + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @object_id: The object id; it must be a valid id within the container that + * created this object; + * + * The function accepts the authentication token of the parent container that + * created the object (not the one that currently owns the object). The object + * is searched within parent using the provided 'object_id'. + * All tokens to the object must be closed before calling destroy. + * + * Return: '0' on Success; error code otherwise. + */ +int dpcon_destroy(struct fsl_mc_io *mc_io, + uint16_t dprc_token, + uint32_t cmd_flags, + uint32_t object_id); + +/** + * dpcon_enable() - Enable the DPCON + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPCON object + * + * Return: '0' on Success; Error code otherwise + */ +int dpcon_enable(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token); + +/** + * dpcon_disable() - Disable the DPCON + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPCON object + * + * Return: '0' on Success; Error code otherwise + */ +int dpcon_disable(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token); + +/** + * dpcon_is_enabled() - Check if the DPCON is enabled. + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPCON object + * @en: Returns '1' if object is enabled; '0' otherwise + * + * Return: '0' on Success; Error code otherwise. + */ +int dpcon_is_enabled(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + int *en); + +/** + * dpcon_reset() - Reset the DPCON, returns the object to initial state. + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPCON object + * + * Return: '0' on Success; Error code otherwise. + */ +int dpcon_reset(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token); + +/** + * struct dpcon_attr - Structure representing DPCON attributes + * @id: DPCON object ID + * @qbman_ch_id: Channel ID to be used by dequeue operation + * @num_priorities: Number of priorities for the DPCON channel (1-8) + */ +struct dpcon_attr { + int id; + uint16_t qbman_ch_id; + uint8_t num_priorities; +}; + +/** + * dpcon_get_attributes() - Retrieve DPCON attributes. + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @token: Token of DPCON object + * @attr: Object's attributes + * + * Return: '0' on Success; Error code otherwise. + */ +int dpcon_get_attributes(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t token, + struct dpcon_attr *attr); + +/** + * dpcon_get_api_version() - Get Data Path Concentrator API version + * @mc_io: Pointer to MC portal's I/O object + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' + * @major_ver: Major version of data path concentrator API + * @minor_ver: Minor version of data path concentrator API + * + * Return: '0' on Success; Error code otherwise. + */ +int dpcon_get_api_version(struct fsl_mc_io *mc_io, + uint32_t cmd_flags, + uint16_t *major_ver, + uint16_t *minor_ver); + +#endif /* __FSL_DPCON_H */ diff --git a/drivers/bus/fslmc/mc/fsl_dpcon_cmd.h b/drivers/bus/fslmc/mc/fsl_dpcon_cmd.h new file mode 100644 index 0000000..f7f7690 --- /dev/null +++ b/drivers/bus/fslmc/mc/fsl_dpcon_cmd.h @@ -0,0 +1,175 @@ +/*- + * This file is provided under a dual BSD/GPLv2 license. When using or + * redistributing this file, you may do so under either license. + * + * BSD LICENSE + * + * Copyright 2013-2016 Freescale Semiconductor Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of the above-listed copyright holders nor the + * names of any contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * GPL LICENSE SUMMARY + * + * ALTERNATIVELY, this software may be distributed under the terms of the + * GNU General Public License ("GPL") as published by the Free Software + * Foundation, either version 2 of that License or (at your option) any + * later version. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef _FSL_DPCON_CMD_H +#define _FSL_DPCON_CMD_H + +/* DPCON Version */ +#define DPCON_VER_MAJOR 3 +#define DPCON_VER_MINOR 2 + +/* Command IDs */ +#define DPCON_CMDID_CLOSE ((0x800 << 4) | (0x1)) +#define DPCON_CMDID_OPEN ((0x808 << 4) | (0x1)) +#define DPCON_CMDID_CREATE ((0x908 << 4) | (0x1)) +#define DPCON_CMDID_DESTROY ((0x988 << 4) | (0x1)) +#define DPCON_CMDID_GET_API_VERSION ((0xa08 << 4) | (0x1)) + +#define DPCON_CMDID_ENABLE ((0x002 << 4) | (0x1)) +#define DPCON_CMDID_DISABLE ((0x003 << 4) | (0x1)) +#define DPCON_CMDID_GET_ATTR ((0x004 << 4) | (0x1)) +#define DPCON_CMDID_RESET ((0x005 << 4) | (0x1)) +#define DPCON_CMDID_IS_ENABLED ((0x006 << 4) | (0x1)) + +#define DPCON_CMDID_SET_IRQ ((0x010 << 4) | (0x1)) +#define DPCON_CMDID_GET_IRQ ((0x011 << 4) | (0x1)) +#define DPCON_CMDID_SET_IRQ_ENABLE ((0x012 << 4) | (0x1)) +#define DPCON_CMDID_GET_IRQ_ENABLE ((0x013 << 4) | (0x1)) +#define DPCON_CMDID_SET_IRQ_MASK ((0x014 << 4) | (0x1)) +#define DPCON_CMDID_GET_IRQ_MASK ((0x015 << 4) | (0x1)) +#define DPCON_CMDID_GET_IRQ_STATUS ((0x016 << 4) | (0x1)) +#define DPCON_CMDID_CLEAR_IRQ_STATUS ((0x017 << 4) | (0x1)) + +#define DPCON_CMDID_SET_NOTIFICATION ((0x100 << 4) | (0x1)) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_OPEN(cmd, dpcon_id) \ + MC_CMD_OP(cmd, 0, 0, 32, int, dpcon_id) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_CREATE(cmd, cfg) \ + MC_CMD_OP(cmd, 0, 0, 8, uint8_t, cfg->num_priorities) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_RSP_IS_ENABLED(cmd, en) \ + MC_RSP_OP(cmd, 0, 0, 1, int, en) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_SET_IRQ(cmd, irq_index, irq_cfg) \ +do { \ + MC_CMD_OP(cmd, 0, 0, 8, uint8_t, irq_index);\ + MC_CMD_OP(cmd, 0, 32, 32, uint32_t, irq_cfg->val);\ + MC_CMD_OP(cmd, 1, 0, 64, uint64_t, irq_cfg->addr);\ + MC_CMD_OP(cmd, 2, 0, 32, int, irq_cfg->irq_num); \ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_GET_IRQ(cmd, irq_index) \ + MC_CMD_OP(cmd, 0, 32, 8, uint8_t, irq_index) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_RSP_GET_IRQ(cmd, type, irq_cfg) \ +do { \ + MC_RSP_OP(cmd, 0, 0, 32, uint32_t, irq_cfg->val);\ + MC_RSP_OP(cmd, 1, 0, 64, uint64_t, irq_cfg->addr);\ + MC_RSP_OP(cmd, 2, 0, 32, int, irq_cfg->irq_num); \ + MC_RSP_OP(cmd, 2, 32, 32, int, type);\ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_SET_IRQ_ENABLE(cmd, irq_index, en) \ +do { \ + MC_CMD_OP(cmd, 0, 0, 8, uint8_t, en); \ + MC_CMD_OP(cmd, 0, 32, 8, uint8_t, irq_index);\ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_GET_IRQ_ENABLE(cmd, irq_index) \ + MC_CMD_OP(cmd, 0, 32, 8, uint8_t, irq_index) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_RSP_GET_IRQ_ENABLE(cmd, en) \ + MC_RSP_OP(cmd, 0, 0, 8, uint8_t, en) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_SET_IRQ_MASK(cmd, irq_index, mask) \ +do { \ + MC_CMD_OP(cmd, 0, 0, 32, uint32_t, mask); \ + MC_CMD_OP(cmd, 0, 32, 8, uint8_t, irq_index);\ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_GET_IRQ_MASK(cmd, irq_index) \ + MC_CMD_OP(cmd, 0, 32, 8, uint8_t, irq_index) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_RSP_GET_IRQ_MASK(cmd, mask) \ + MC_RSP_OP(cmd, 0, 0, 32, uint32_t, mask) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_GET_IRQ_STATUS(cmd, irq_index, status) \ +do { \ + MC_CMD_OP(cmd, 0, 0, 32, uint32_t, status);\ + MC_CMD_OP(cmd, 0, 32, 8, uint8_t, irq_index);\ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_RSP_GET_IRQ_STATUS(cmd, status) \ + MC_RSP_OP(cmd, 0, 0, 32, uint32_t, status) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_CLEAR_IRQ_STATUS(cmd, irq_index, status) \ +do { \ + MC_CMD_OP(cmd, 0, 0, 32, uint32_t, status); \ + MC_CMD_OP(cmd, 0, 32, 8, uint8_t, irq_index);\ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_RSP_GET_ATTR(cmd, attr) \ +do { \ + MC_RSP_OP(cmd, 0, 0, 32, int, attr->id);\ + MC_RSP_OP(cmd, 0, 32, 16, uint16_t, attr->qbman_ch_id);\ + MC_RSP_OP(cmd, 0, 48, 8, uint8_t, attr->num_priorities);\ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_CMD_SET_NOTIFICATION(cmd, cfg) \ +do { \ + MC_CMD_OP(cmd, 0, 0, 32, int, cfg->dpio_id);\ + MC_CMD_OP(cmd, 0, 32, 8, uint8_t, cfg->priority);\ + MC_CMD_OP(cmd, 1, 0, 64, uint64_t, cfg->user_ctx);\ +} while (0) + +/* cmd, param, offset, width, type, arg_name */ +#define DPCON_RSP_GET_API_VERSION(cmd, major, minor) \ +do { \ + MC_RSP_OP(cmd, 0, 0, 16, uint16_t, major);\ + MC_RSP_OP(cmd, 0, 16, 16, uint16_t, minor);\ +} while (0) + +#endif /* _FSL_DPCON_CMD_H */ diff --git a/drivers/bus/fslmc/rte_bus_fslmc_version.map b/drivers/bus/fslmc/rte_bus_fslmc_version.map index 4c03e67..92a7342 100644 --- a/drivers/bus/fslmc/rte_bus_fslmc_version.map +++ b/drivers/bus/fslmc/rte_bus_fslmc_version.map @@ -53,5 +53,7 @@ DPDK_17.05 { DPDK_17.08 { global: + dpcon_open; + dpcon_get_attributes; rte_fslmc_object_register; } DPDK_17.05; -- 1.9.1