From patchwork Tue Dec 6 03:52:19 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob X-Patchwork-Id: 17691 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 BAD4D558D; Tue, 6 Dec 2016 04:53:47 +0100 (CET) Received: from NAM01-BN3-obe.outbound.protection.outlook.com (mail-bn3nam01on0060.outbound.protection.outlook.com [104.47.33.60]) by dpdk.org (Postfix) with ESMTP id 102D92BC5 for ; Tue, 6 Dec 2016 04:52:55 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=CAVIUMNETWORKS.onmicrosoft.com; s=selector1-cavium-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version; bh=nkEK1m1u3JzvakgFDcX3RoBICTp6RhJ+y1rHjM3zkk0=; b=EXqSOYrnewI/c7rEi9/xA+8NLDwxPf5eUenKfpEA7dnD+nVw1fjir8tqe7KRiOE+mn3tIjn4tXjOgsCPhW2q2Uh1y6J3X8t+TK9FX3B0+4wBIvMmjvt3bKnbRD1rj3QDyljKPr4WRuJzUvc/xySCN7R76w/SyYpN8TaXuEzsPPg= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=Jerin.Jacob@cavium.com; Received: from localhost.caveonetworks.com (50.233.148.156) by BY1PR0701MB1723.namprd07.prod.outlook.com (10.162.111.142) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P384) id 15.1.693.12; Tue, 6 Dec 2016 03:52:51 +0000 From: Jerin Jacob To: CC: , , , , , Jerin Jacob Date: Tue, 6 Dec 2016 09:22:19 +0530 Message-ID: <1480996340-29871-6-git-send-email-jerin.jacob@caviumnetworks.com> X-Mailer: git-send-email 2.5.5 In-Reply-To: <1480996340-29871-1-git-send-email-jerin.jacob@caviumnetworks.com> References: <1479447902-3700-2-git-send-email-jerin.jacob@caviumnetworks.com> <1480996340-29871-1-git-send-email-jerin.jacob@caviumnetworks.com> MIME-Version: 1.0 X-Originating-IP: [50.233.148.156] X-ClientProxiedBy: BLUPR13CA0014.namprd13.prod.outlook.com (10.160.191.24) To BY1PR0701MB1723.namprd07.prod.outlook.com (10.162.111.142) X-Microsoft-Exchange-Diagnostics: 1; BY1PR0701MB1723; 2:GDLd6N9Xd6vlB0y1Kw21putGP8B5poRl+HHGjtPCa9Rz9IHSnVkgwSy8RfA38KTUW36k1xCS+IW7+VHzFtaneI2QmtUsnbbWWBrcysWJWy+8vazOdDTUncOD7mWKeXAagzCGaRQUNtvqLiw/A9vVSKylp3QS23C+dJAFcZZ7C5E=; 3:I9DzX18EFzi2KuGc7LgoEbDGqQQmtEaNuWPaP6qovXd5r0biXdy8ZgF/ikc2XB0pYtCY3oQ2E9ihO+K0uN243/bcoBd8mzAwm1lMtb2HIKVYtjRZKSQoC3/f8waXJXRpph02bCyrewDpXM5VCcs1GJSbBZYGGsrH2ouAswtNP00= X-MS-Office365-Filtering-Correlation-Id: 1ff3acfe-bab7-4578-a21d-08d41d8b5af8 X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(22001); SRVR:BY1PR0701MB1723; X-Microsoft-Exchange-Diagnostics: 1; BY1PR0701MB1723; 25:pSBh2tipYNuMY3p4f/yj5R4XyKP2Q+E6TI+IS3oymgTetqYU9Ko0eZcJIie6y4M3cSaOM3fwJg5nDFSMcLknEpi3fke/pEK8mNm2L0ViIVlhIp1qR+zSvCAAVPDBoVaIp7jGZ/jnA67KrRt3s+MccotyKazePspRhYVrFDyeby3+ELNLPprQqGz7VVOhb9I9qIS0dfOWnE3KYMDDVgLJG1m2y2xaYE3uxnuARWi+dLWyuJNgaxsPomEEwTBcINPs9Vf/SaOAs9v5ZzB625pPw7WLwYRWWVl/l8uLN3yfTfzUPWc4rnrn7hCgH5raI73udRSvvCpMKuqKUnnNlxmkvH1VsRGT1y7w8JhbFcxjBc5UirfpHJnIAWhzqqOZ7A0pFoEPY8YhVHgxYN2a1RV/oETjLqX9Hl48jdJr5sekqdyho9DmEx1VMXoVu8r+3BKe5xCCPB3YS/WjIwp06Dexk2Tighc3GnMRbWndQbpm+Fxf41Qp1Fwz5oSjw4prRy1DPC3aZf1XZfwk3RvO6tKkgkkopJXLnnlyBt5eSOHnmG3yHDAzCiJrbPGtnCZVIfF5v/pqyxOFrgvIqweaRfUQ9OR/nsuMIfd1mvfAwaVrck0kvOd/5zLrXqbbzYufWLSEIUNH2lDwKRSc+ZAdhgMnc59E/AgsVkJ/9JpphTjlXt5wt3cL2BWW+KH/ey8xRmEtFbngZ28tz00QMVoFkT5ZdGsGRt5CKV08IXaDS0iqjc7Kw9W8751IvpYx50f6LTEGeOcMPUMzaBQWWs01Ef+n6zay61cU8NRDYVQKP243ZE5GRGlNelDbF787QFxlsN9M X-Microsoft-Exchange-Diagnostics: 1; BY1PR0701MB1723; 31:Lg6YKj0QbS6tlmo48OJfugG4xK+1i4trFnQo296mdvrzHkeItZAfr6FXxAKsJdugEABVmbQxzCdB87rdNS77WQ9N4j88nPJYCL5z5R/PDNv470Ss00nRcN03ngrDqlai/I4MuVx26s598LFRgPVmeCzHED6thFVMl4u4JSGI1K6DGkqkr2QiYSR6Df9MeHh8z1ReLUAC+xIvXs2Z0FDPlE/FcsYWLQyIs3yAQID1KNS99V7RLJ1Ao49i6d61qgUg; 20:a1GC/dWxipoUsw5oLP0fqwEL3KUknf7GyzoTNjxY0n/HIT6v9n/DHdt49WKZxEU2/pzaln3bzYFpOSpFiu3wxalqbnX/3rELo68VuG3mNzGnDU/KR8tXv4CGbrjDn/+Ci0S6d3Idr9rXkxRsJH/gnnaGXBOELikABipYJREKrld/+itE+CFjnIDFhpo4HUgqDzN1ME+PfVYhyObtA24iEgcWH6NETyzFjPKaKqoKijOH03WWTutUoL6ciX419m72IlaHn8OTiefI/0bT17YKiamkDHi4mFNdskempytQNBc0YFCutZiezmbl4GVZCwUM4dPnS4mFTJ2qZL/KWEnQyMbCxNhNkenko2Vo/B57t8+CB53cPPhzhSgJgn4tgUcIhrZyDI8kBlEp4LrrJvtvISZOyR6jhSPKWwSHOO+179oz27hL1YuWt4rMGYO7QO1cZ45WuhPtE64Y1xjr0ZW/8YD/TBJyHUY4kncNLkw30zLfl0KMVoNU9Mshl0cerNMU4hkhpzNWL6+FcFhQiWUos0XnM52yVpqyOO4pDt3m5NEy7TDX/CvfOrP0CXgugAW1wSuMX4Ra09P8r+sYf7wfdXw74v5fCVBSjbsumUDoMgA= X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:; X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(6040375)(601004)(2401047)(5005006)(8121501046)(10201501046)(3002001)(6041248)(20161123555025)(20161123564025)(20161123562025)(20161123560025)(6072148); SRVR:BY1PR0701MB1723; BCL:0; PCL:0; RULEID:; SRVR:BY1PR0701MB1723; X-Microsoft-Exchange-Diagnostics: 1; BY1PR0701MB1723; 4:CzDZ+g8bxcbZD8n4YvOkezz6P5xtuAy/P1uo4CK1H0P6i2fd9n4Ku3dxG2qQYaTcrFYIxoFLLU9f3P7EAeQ/dcOY5SG36V8GwweIAadDebsXmgz01+zs89Zyn/YJ8YfMmKevzYAs2Oj5vvj7YYPp9jsQs2+O8+wwc6yaW8SiHJhvMg6AjcmSq40rj+9oJF5Qb7NzdxH6XJFaoUcyZspA4QijCEU4yRmv9D7y1xCbVZOwscb7af9aPQEaNKiejds28jAOkij6QXis9eY9k1HtBdi1Lr47c5qvDks4df8z1NwVexOwnGosshwji9PsBXpUVU5d8Q59S17tBFbFYxKcgRkhVBl4YNmCP957mTWpT7ULkCjV93kNMR8fgta8phu71J7plw1/SnDEKGQOGWx49W/t5uQX+esDZUp2rCZ4DnH5+E6yYxMUbPOm4F65cpUUYP/oGTRqE4FWkmPARgseTSUWkaDfBxicF0gpwJBUSXBzr2AKqPDlHCzo/W/ZaqtEDOqnOcH+LLBujrTYmVVgjAVWnthVXfDexL0/3I7RD5oTI/c8+/5dlmOUYnQr8Xqz/q3LA6Mip19SSsVYihn9Kw== X-Forefront-PRVS: 01480965DA X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(4630300001)(6069001)(6009001)(7916002)(199003)(189002)(101416001)(110136003)(6916009)(69596002)(4326007)(8666005)(106356001)(76176999)(2351001)(47776003)(97736004)(2906002)(107886002)(7846002)(5660300001)(92566002)(305945005)(48376002)(733004)(42882006)(68736007)(50986999)(39850400001)(50466002)(6666003)(36756003)(2950100002)(575784001)(81156014)(105586002)(42186005)(3846002)(33646002)(81166006)(8676002)(5003940100001)(6512006)(6506006)(6486002)(53416004)(7736002)(189998001)(38730400001)(4001430100002)(6116002)(50226002)(39840400001)(39450400002)(39410400001)(66066001)(76506005)(7059030); DIR:OUT; SFP:1101; SCL:1; SRVR:BY1PR0701MB1723; H:localhost.caveonetworks.com; FPR:; SPF:None; PTR:InfoNoRecords; A:1; MX:1; LANG:en; Received-SPF: None (protection.outlook.com: cavium.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; BY1PR0701MB1723; 23:GEy42hELRzKyTdB2xlq54qSiMmjAFP5CbUbmvqt?= =?us-ascii?Q?JO1I261dnN7vw4BIMKAqePfrgMR7/CI4+TOFvBh31r8aXj5yrCV7/iocqweZ?= =?us-ascii?Q?ItHaevGrF5ypwENdPQioBrLlJ7yoIoxHpI4h8HqmJ3riKnUs2yLQ9Zyq/q1P?= =?us-ascii?Q?SxasIfyr1NeSw4udf2JIgcryJ+3zS+4wVVLJDLxe01Sj8f2OEAEY4holf8zL?= =?us-ascii?Q?o6vXe7DNvQmExN3MXa5aj+Ex9IzwNtm5Nq+hVGTEUTeK6Dl4puUyGwJpDmnl?= =?us-ascii?Q?aZyN/lgrJRVzCiF6oZUC2dUKbm7yslV2PB/871deuM5zo74Zwzh1rKwkgCpi?= =?us-ascii?Q?hDCBcaOBetNof94QIs9/TIpZYnTjy6X2XLHrtNd0Mfc+7bu18bQPPRWFQEI0?= =?us-ascii?Q?I0h6nzs03BWc4mb/eHoF7BBqX/qcU0EPn6BEwhX7jGk7VcampGi1Y1G3DtxH?= =?us-ascii?Q?PFSz50CsBgxFzwQhSnfiVfkouZK1DZEc1unlt43Vp4VFEoR2QVmev/NU0/Tp?= =?us-ascii?Q?VJvoK1uT+1oZWVjzexW5Iy9Li5/5eWWOPqEbPrGIlBBtaBtOTxugL/yZiQAg?= =?us-ascii?Q?R5Yrb5/TJmjJcoNkUfYLKJbN65wWg+EDUHLdNXwXdakUoOxsuDbQqW0jGv0O?= =?us-ascii?Q?Tr/StVEjWWb01UhlJKBKJlsJcfK/0f7WgW0FZQDLxK3vAAPt7soFTLF0EXNX?= =?us-ascii?Q?hQ2hIVK2NSPhghyCxhoYXdMp++2PWlX4G2v8q9ew4DZj+d0KYPJjkXmDOx9H?= =?us-ascii?Q?CE5QjDJEqKeAf/sPKcr+ZhitlF7N7BpGIcmx1FfPZFqNIyCCEQ5B+QMHuX9N?= =?us-ascii?Q?6+35GcQhNBdyRPk7bUdMTgjJtOQyrktSMYKf5xh1Zx0FUHnhsqjuCD1yyo8O?= =?us-ascii?Q?r+u+3tEHkFkSybzJZygP3Noranm5M0LkkGIPJc0bun9J9TgbjMGQY+5WkgIr?= =?us-ascii?Q?LFRNZ6yveWZA2WzTsj24Vcil8g8J5VTxGZgb29DsC3ftqwa24+ij/cWSuX5u?= =?us-ascii?Q?y2utWkQhDSMxoWPRkqWmNA9Ouzaad/mpY2ZpQtwSYiI1F1Ya5kaWSIuVvU02?= =?us-ascii?Q?yqTNucUGWoCkU0vZiGST+ABENdQOHgAB6AVh/9EcHzGUh5Gui/lQzJVQfGZD?= =?us-ascii?Q?1y0kReqPCsCz9qrJ3TWI7gb/ZQXeWkcQw6foNjSEoDf/Ofy8hVVs6eDeOngX?= =?us-ascii?Q?RsZDnoRXeDYGI/Tjn0vDm0it0jaCsOGx1t07WkDDnECJE2xdRGNN6DB8NwDF?= =?us-ascii?Q?oEDRF72jxhouXqhbA00bccmnByIqiiCUniYMLvoKEV5seBmttQk98biV2jJo?= =?us-ascii?Q?CDyACX2+CDtPRVfTRZXksZHyzPMobYyLhvpX+uI8NI5Qn5Z0ChtNz1KW6f7e?= =?us-ascii?Q?JA01kenrzXyR7A+UIL0Uhoq9ZYnXp89kiKxnDX6YxpO/jx+abtjZNwm9HE0j?= =?us-ascii?Q?qOif88zrViQ=3D=3D?= X-Microsoft-Exchange-Diagnostics: 1; BY1PR0701MB1723; 6:RdpMrNAvJfDFQ3wyt6AfSRbJT/eu36wo1ip1DN8RhM0VN9qB+XFj9d+99xIBLnJyG0ed3jtIX3PPWxtR2r/YGFyVKDj4A4b7OtL9zP64rDyDJ4J+KKjq/fcH7fhaqpZi0D4aic70Z84AciEkZxCjhzmCjQCTF1iZTPlZaJJPtzleP7g7C9VW6MOJqJRlB2XdfD93iXoHEcukpVVr3T1uT2ZcqYm9BEdtlE8VbiNCMBMOrZshtRZkNdKO9zRlS+rd7l99xm8zIs05QNsvMmNTTbRQChrFyghvTHjcJOYXb4IYnq1ojAhNIOLT3HMo1unYvnaHkyBUrF7qxHKuci+NT5l7wYZTVY4ojYoBkpJ4U8E=; 5:B27Z4xu8nrC+3xgmSrk1Z6RxScXxLn3b41FDDqGar8Zed/aMgbVE1HZy49OKwRiGnwA148R+uQTbi5Bj90vIGGuIxh6rHM+lKZyOlMOcL475GrnUcppWR6tS1QzZpTRb5KaW3brEunZlbpWn5jWfZQ==; 24:9jviYzfKbaxNlk3AlEmQkXy9bhL7y/Xj+o35QUR4OswCX9qqtfzOK8OMr1/c4FinlaZbMR+r3rnJf6balHlgm5mRoQXYs86oj/opn38x8hI= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; BY1PR0701MB1723; 7:iTrb1J7WkkAl3AZfaGpvS11na4FkK4hIv0tMc9SA1yMG9CtvqSoUx10FDb2LlMsrexAvAsn8pAQqmeYWkBPlHzEibI09PpixnpY0qGYbkPbm7BJubT4W34pGcFh8VLH/+9NehKo59+FBmqAe2mg3z3bp3/5JBrE+g64/JklmYuFybEBgJU7efV4RSOu+mV1iiHgvX7jgEghUG8aJxpIyjkFTQlbPt3mxdiZ7GL6Gpd80YOFovbZbuNpkwx7Wc1siWhNHIpAwVXo/DtSlyxK3XJK12vy3GGaAzoDGWgZyveVtVn/W8onzAR4y8DZ27KbrAz8ewGWx6dtEEGxiV/ISKCzKtuqN/74cUXH2oiRoF6I= X-OriginatorOrg: caviumnetworks.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 06 Dec 2016 03:52:51.7845 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-Transport-CrossTenantHeadersStamped: BY1PR0701MB1723 Subject: [dpdk-dev] [PATCH v2 5/6] event/skeleton: add skeleton eventdev driver 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" The skeleton driver facilitates, bootstrapping the new eventdev driver and creates a platform to verify the northbound eventdev common code. The driver supports both VDEV and PCI based eventdev devices. Signed-off-by: Jerin Jacob --- MAINTAINERS | 1 + config/common_base | 8 + drivers/Makefile | 1 + drivers/event/Makefile | 36 ++ drivers/event/skeleton/Makefile | 55 +++ .../skeleton/rte_pmd_skeleton_event_version.map | 4 + drivers/event/skeleton/skeleton_eventdev.c | 540 +++++++++++++++++++++ drivers/event/skeleton/skeleton_eventdev.h | 72 +++ mk/rte.app.mk | 4 + 9 files changed, 721 insertions(+) create mode 100644 drivers/event/Makefile create mode 100644 drivers/event/skeleton/Makefile create mode 100644 drivers/event/skeleton/rte_pmd_skeleton_event_version.map create mode 100644 drivers/event/skeleton/skeleton_eventdev.c create mode 100644 drivers/event/skeleton/skeleton_eventdev.h diff --git a/MAINTAINERS b/MAINTAINERS index 8e59352..a10899f 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -252,6 +252,7 @@ F: examples/l2fwd-crypto/ Eventdev API - EXPERIMENTAL M: Jerin Jacob F: lib/librte_eventdev/ +F: drivers/event/skeleton/ Networking Drivers ------------------ diff --git a/config/common_base b/config/common_base index 7a8814e..35aef0a 100644 --- a/config/common_base +++ b/config/common_base @@ -417,6 +417,14 @@ CONFIG_RTE_LIBRTE_EVENTDEV=y CONFIG_RTE_LIBRTE_EVENTDEV_DEBUG=n CONFIG_RTE_EVENT_MAX_DEVS=16 CONFIG_RTE_EVENT_MAX_QUEUES_PER_DEV=64 + +# +# Compile PMD for skeleton event device +# +CONFIG_RTE_LIBRTE_PMD_SKELETON_EVENTDEV=y +CONFIG_RTE_LIBRTE_PMD_SKELETON_EVENTDEV_DEBUG=n + +# # Compile librte_ring # CONFIG_RTE_LIBRTE_RING=y diff --git a/drivers/Makefile b/drivers/Makefile index 81c03a8..40b8347 100644 --- a/drivers/Makefile +++ b/drivers/Makefile @@ -33,5 +33,6 @@ include $(RTE_SDK)/mk/rte.vars.mk DIRS-y += net DIRS-$(CONFIG_RTE_LIBRTE_CRYPTODEV) += crypto +DIRS-$(CONFIG_RTE_LIBRTE_EVENTDEV) += event include $(RTE_SDK)/mk/rte.subdir.mk diff --git a/drivers/event/Makefile b/drivers/event/Makefile new file mode 100644 index 0000000..678279f --- /dev/null +++ b/drivers/event/Makefile @@ -0,0 +1,36 @@ +# BSD LICENSE +# +# Copyright(c) 2016 Cavium networks. All rights reserved. +# All rights reserved. +# +# 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 Cavium networks nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# 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 +# OWNER 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 $(RTE_SDK)/mk/rte.vars.mk + +DIRS-$(CONFIG_RTE_LIBRTE_PMD_SKELETON_EVENTDEV) += skeleton + +include $(RTE_SDK)/mk/rte.subdir.mk diff --git a/drivers/event/skeleton/Makefile b/drivers/event/skeleton/Makefile new file mode 100644 index 0000000..e557f6d --- /dev/null +++ b/drivers/event/skeleton/Makefile @@ -0,0 +1,55 @@ +# BSD LICENSE +# +# Copyright(c) 2016 Cavium Networks. All rights reserved. +# All rights reserved. +# +# 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 Cavium Networks nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# 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 +# OWNER 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 $(RTE_SDK)/mk/rte.vars.mk + +# +# library name +# +LIB = librte_pmd_skeleton_event.a + +CFLAGS += $(WERROR_FLAGS) + +EXPORT_MAP := rte_pmd_skeleton_event_version.map + +LIBABIVER := 1 + +# +# all source are stored in SRCS-y +# +SRCS-$(CONFIG_RTE_LIBRTE_PMD_SKELETON_EVENTDEV) += skeleton_eventdev.c + +# this lib depends upon: +DEPDIRS-$(CONFIG_RTE_LIBRTE_PMD_SKELETON_EVENTDEV) += lib/librte_eal +DEPDIRS-$(CONFIG_RTE_LIBRTE_PMD_SKELETON_EVENTDEV) += lib/librte_event + +include $(RTE_SDK)/mk/rte.lib.mk diff --git a/drivers/event/skeleton/rte_pmd_skeleton_event_version.map b/drivers/event/skeleton/rte_pmd_skeleton_event_version.map new file mode 100644 index 0000000..31eca32 --- /dev/null +++ b/drivers/event/skeleton/rte_pmd_skeleton_event_version.map @@ -0,0 +1,4 @@ +DPDK_17.02 { + + local: *; +}; diff --git a/drivers/event/skeleton/skeleton_eventdev.c b/drivers/event/skeleton/skeleton_eventdev.c new file mode 100644 index 0000000..ec3be4f --- /dev/null +++ b/drivers/event/skeleton/skeleton_eventdev.c @@ -0,0 +1,540 @@ +/* + * BSD LICENSE + * + * Copyright (C) Cavium networks Ltd. 2016. + * + * 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 Cavium networks nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 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 + * OWNER 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 +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "skeleton_eventdev.h" + +#define EVENTDEV_NAME_SKELETON_PMD event_skeleton +/**< Skeleton event device PMD name */ + +static uint16_t +skeleton_eventdev_enqueue(void *port, struct rte_event *ev) +{ + struct skeleton_port *sp = port; + + RTE_SET_USED(sp); + RTE_SET_USED(ev); + RTE_SET_USED(port); + + return 0; +} + +static uint16_t +skeleton_eventdev_enqueue_burst(void *port, struct rte_event ev[], + uint16_t nb_events) +{ + struct skeleton_port *sp = port; + + RTE_SET_USED(sp); + RTE_SET_USED(ev); + RTE_SET_USED(port); + RTE_SET_USED(nb_events); + + return 0; +} + +static uint16_t +skeleton_eventdev_dequeue(void *port, struct rte_event *ev, + uint64_t timeout_ticks) +{ + struct skeleton_port *sp = port; + + RTE_SET_USED(sp); + RTE_SET_USED(ev); + RTE_SET_USED(timeout_ticks); + + return 0; +} + +static uint16_t +skeleton_eventdev_dequeue_burst(void *port, struct rte_event ev[], + uint16_t nb_events, uint64_t timeout_ticks) +{ + struct skeleton_port *sp = port; + + RTE_SET_USED(sp); + RTE_SET_USED(ev); + RTE_SET_USED(nb_events); + RTE_SET_USED(timeout_ticks); + + return 0; +} + +static void +skeleton_eventdev_info_get(struct rte_eventdev *dev, + struct rte_event_dev_info *dev_info) +{ + struct skeleton_eventdev *skel = skeleton_pmd_priv(dev); + + PMD_DRV_FUNC_TRACE(); + + RTE_SET_USED(skel); + + dev_info->min_dequeue_timeout_ns = 1; + dev_info->max_dequeue_timeout_ns = 10000; + dev_info->dequeue_timeout_ns = 25; + dev_info->max_event_queues = 64; + dev_info->max_event_queue_flows = (1ULL << 20); + dev_info->max_event_queue_priority_levels = 8; + dev_info->max_event_priority_levels = 8; + dev_info->max_event_ports = 32; + dev_info->max_event_port_dequeue_depth = 16; + dev_info->max_event_port_enqueue_depth = 16; + dev_info->max_num_events = (1ULL << 20); + dev_info->event_dev_cap = RTE_EVENT_DEV_CAP_FLAG_QUEUE_QOS | + RTE_EVENT_DEV_CAP_FLAG_EVENT_QOS; +} + +static int +skeleton_eventdev_configure(const struct rte_eventdev *dev) +{ + struct rte_eventdev_data *data = dev->data; + struct rte_event_dev_config *conf = &data->dev_conf; + struct skeleton_eventdev *skel = skeleton_pmd_priv(dev); + + PMD_DRV_FUNC_TRACE(); + + RTE_SET_USED(conf); + RTE_SET_USED(skel); + + PMD_DRV_LOG(DEBUG, "Configured eventdev devid=%d", dev->data->dev_id); + return 0; +} + +static int +skeleton_eventdev_start(struct rte_eventdev *dev) +{ + struct skeleton_eventdev *skel = skeleton_pmd_priv(dev); + + PMD_DRV_FUNC_TRACE(); + + RTE_SET_USED(skel); + + return 0; +} + +static void +skeleton_eventdev_stop(struct rte_eventdev *dev) +{ + struct skeleton_eventdev *skel = skeleton_pmd_priv(dev); + + PMD_DRV_FUNC_TRACE(); + + RTE_SET_USED(skel); +} + +static int +skeleton_eventdev_close(struct rte_eventdev *dev) +{ + struct skeleton_eventdev *skel = skeleton_pmd_priv(dev); + + PMD_DRV_FUNC_TRACE(); + + RTE_SET_USED(skel); + + return 0; +} + +static void +skeleton_eventdev_queue_def_conf(struct rte_eventdev *dev, uint8_t queue_id, + struct rte_event_queue_conf *queue_conf) +{ + struct skeleton_eventdev *skel = skeleton_pmd_priv(dev); + + PMD_DRV_FUNC_TRACE(); + + RTE_SET_USED(skel); + RTE_SET_USED(queue_id); + + queue_conf->nb_atomic_flows = (1ULL << 20); + queue_conf->nb_atomic_order_sequences = (1ULL << 20); + queue_conf->event_queue_cfg = RTE_EVENT_QUEUE_CFG_FLAG_DEFAULT; + queue_conf->priority = RTE_EVENT_DEV_PRIORITY_NORMAL; +} + +static void +skeleton_eventdev_queue_release(void *queue) +{ + struct skeleton_queue *sq = queue; + PMD_DRV_FUNC_TRACE(); + + rte_free(sq); +} + +static int +skeleton_eventdev_queue_setup(struct rte_eventdev *dev, uint8_t queue_id, + const struct rte_event_queue_conf *queue_conf) +{ + struct skeleton_queue *sq; + struct skeleton_eventdev *skel = skeleton_pmd_priv(dev); + + PMD_DRV_FUNC_TRACE(); + + RTE_SET_USED(skel); + RTE_SET_USED(queue_conf); + + /* Free memory prior to re-allocation if needed */ + if (dev->data->queues[queue_id] != NULL) { + PMD_DRV_LOG(DEBUG, "Freeing memory prior to re-allocation %d", + queue_id); + skeleton_eventdev_queue_release(dev->data->queues[queue_id]); + dev->data->queues[queue_id] = NULL; + } + + /* Allocate event queue memory */ + sq = rte_zmalloc_socket("eventdev queue", + sizeof(struct skeleton_queue), RTE_CACHE_LINE_SIZE, + dev->data->socket_id); + if (sq == NULL) { + PMD_DRV_ERR("Failed to allocate sq queue_id=%d", queue_id); + return -ENOMEM; + } + + sq->queue_id = queue_id; + + PMD_DRV_LOG(DEBUG, "[%d] sq=%p", queue_id, sq); + + dev->data->queues[queue_id] = sq; + return 0; +} + +static void +skeleton_eventdev_port_def_conf(struct rte_eventdev *dev, uint8_t port_id, + struct rte_event_port_conf *port_conf) +{ + struct skeleton_eventdev *skel = skeleton_pmd_priv(dev); + + PMD_DRV_FUNC_TRACE(); + + RTE_SET_USED(skel); + RTE_SET_USED(port_id); + + port_conf->new_event_threshold = 32 * 1024; + port_conf->dequeue_depth = 16; + port_conf->enqueue_depth = 16; +} + +static void +skeleton_eventdev_port_release(void *port) +{ + struct skeleton_port *sp = port; + PMD_DRV_FUNC_TRACE(); + + rte_free(sp); +} + +static int +skeleton_eventdev_port_setup(struct rte_eventdev *dev, uint8_t port_id, + const struct rte_event_port_conf *port_conf) +{ + struct skeleton_port *sp; + struct skeleton_eventdev *skel = skeleton_pmd_priv(dev); + + PMD_DRV_FUNC_TRACE(); + + RTE_SET_USED(skel); + RTE_SET_USED(port_conf); + + /* Free memory prior to re-allocation if needed */ + if (dev->data->ports[port_id] != NULL) { + PMD_DRV_LOG(DEBUG, "Freeing memory prior to re-allocation %d", + port_id); + skeleton_eventdev_port_release(dev->data->ports[port_id]); + dev->data->ports[port_id] = NULL; + } + + /* Allocate event port memory */ + sp = rte_zmalloc_socket("eventdev port", + sizeof(struct skeleton_port), RTE_CACHE_LINE_SIZE, + dev->data->socket_id); + if (sp == NULL) { + PMD_DRV_ERR("Failed to allocate sp port_id=%d", port_id); + return -ENOMEM; + } + + sp->port_id = port_id; + + PMD_DRV_LOG(DEBUG, "[%d] sp=%p", port_id, sp); + + dev->data->ports[port_id] = sp; + return 0; +} + +static int +skeleton_eventdev_port_link(void *port, + const struct rte_event_queue_link link[], + uint16_t nb_links) +{ + struct skeleton_port *sp = port; + PMD_DRV_FUNC_TRACE(); + + RTE_SET_USED(sp); + RTE_SET_USED(link); + + /* Linked all the queues */ + return (int)nb_links; +} + +static int +skeleton_eventdev_port_unlink(void *port, uint8_t queues[], + uint16_t nb_unlinks) +{ + struct skeleton_port *sp = port; + PMD_DRV_FUNC_TRACE(); + + RTE_SET_USED(sp); + RTE_SET_USED(queues); + + /* Unlinked all the queues */ + return (int)nb_unlinks; + +} + +static void +skeleton_eventdev_timeout_ticks(struct rte_eventdev *dev, uint64_t ns, + uint64_t *timeout_ticks) +{ + struct skeleton_eventdev *skel = skeleton_pmd_priv(dev); + uint32_t scale = 1; + + PMD_DRV_FUNC_TRACE(); + + RTE_SET_USED(skel); + *timeout_ticks = ns * scale; +} + +static void +skeleton_eventdev_dump(struct rte_eventdev *dev, FILE *f) +{ + struct skeleton_eventdev *skel = skeleton_pmd_priv(dev); + + PMD_DRV_FUNC_TRACE(); + + RTE_SET_USED(skel); + RTE_SET_USED(f); +} + + +/* Initialize and register event driver with DPDK Application */ +static const struct rte_eventdev_ops skeleton_eventdev_ops = { + .dev_infos_get = skeleton_eventdev_info_get, + .dev_configure = skeleton_eventdev_configure, + .dev_start = skeleton_eventdev_start, + .dev_stop = skeleton_eventdev_stop, + .dev_close = skeleton_eventdev_close, + .queue_def_conf = skeleton_eventdev_queue_def_conf, + .queue_setup = skeleton_eventdev_queue_setup, + .queue_release = skeleton_eventdev_queue_release, + .port_def_conf = skeleton_eventdev_port_def_conf, + .port_setup = skeleton_eventdev_port_setup, + .port_release = skeleton_eventdev_port_release, + .port_link = skeleton_eventdev_port_link, + .port_unlink = skeleton_eventdev_port_unlink, + .timeout_ticks = skeleton_eventdev_timeout_ticks, + .dump = skeleton_eventdev_dump +}; + +static int +skeleton_eventdev_init(struct rte_eventdev *eventdev) +{ + struct rte_pci_device *pci_dev; + struct skeleton_eventdev *skel = skeleton_pmd_priv(eventdev); + int ret = 0; + + PMD_DRV_FUNC_TRACE(); + + eventdev->dev_ops = &skeleton_eventdev_ops; + eventdev->schedule = NULL; + eventdev->enqueue = skeleton_eventdev_enqueue; + eventdev->enqueue_burst = skeleton_eventdev_enqueue_burst; + eventdev->dequeue = skeleton_eventdev_dequeue; + eventdev->dequeue_burst = skeleton_eventdev_dequeue_burst; + + /* For secondary processes, the primary has done all the work */ + if (rte_eal_process_type() != RTE_PROC_PRIMARY) + return 0; + + pci_dev = eventdev->pci_dev; + + skel->reg_base = (uintptr_t)pci_dev->mem_resource[0].addr; + if (!skel->reg_base) { + PMD_DRV_ERR("Failed to map BAR0"); + ret = -ENODEV; + goto fail; + } + + skel->device_id = pci_dev->id.device_id; + skel->vendor_id = pci_dev->id.vendor_id; + skel->subsystem_device_id = pci_dev->id.subsystem_device_id; + skel->subsystem_vendor_id = pci_dev->id.subsystem_vendor_id; + + PMD_DRV_LOG(DEBUG, "pci device (%x:%x) %u:%u:%u:%u", + pci_dev->id.vendor_id, pci_dev->id.device_id, + pci_dev->addr.domain, pci_dev->addr.bus, + pci_dev->addr.devid, pci_dev->addr.function); + + PMD_DRV_LOG(INFO, "dev_id=%d socket_id=%d (%x:%x)", + eventdev->data->dev_id, eventdev->data->socket_id, + skel->vendor_id, skel->device_id); + +fail: + return ret; +} + +/* PCI based event device */ + +#define EVENTDEV_SKEL_VENDOR_ID 0x177d +#define EVENTDEV_SKEL_PRODUCT_ID 0x0001 + +static const struct rte_pci_id pci_id_skeleton_map[] = { + { + RTE_PCI_DEVICE(EVENTDEV_SKEL_VENDOR_ID, + EVENTDEV_SKEL_PRODUCT_ID) + }, + { + .vendor_id = 0, + }, +}; + +static struct rte_eventdev_driver pci_eventdev_skeleton_pmd = { + .pci_drv = { + .id_table = pci_id_skeleton_map, + .drv_flags = RTE_PCI_DRV_NEED_MAPPING, + .probe = rte_event_pmd_pci_probe, + .remove = rte_event_pmd_pci_remove, + }, + .eventdev_init = skeleton_eventdev_init, + .dev_private_size = sizeof(struct skeleton_eventdev), +}; + +RTE_PMD_REGISTER_PCI(event_skeleton_pci, pci_eventdev_skeleton_pmd.pci_drv); +RTE_PMD_REGISTER_PCI_TABLE(event_skeleton_pci, pci_id_skeleton_map); + +/* VDEV based event device */ + +/** + * Global static parameter used to create a unique name for each skeleton + * event device. + */ +static unsigned int skeleton_unique_id; + +static inline int +skeleton_create_unique_device_name(char *name, size_t size) +{ + int ret; + + if (name == NULL) + return -EINVAL; + + ret = snprintf(name, size, "%s_%u", RTE_STR(EVENTDEV_NAME_SKELETON_PMD), + skeleton_unique_id++); + if (ret < 0) + return ret; + return 0; +} + +static int +skeleton_eventdev_create(int socket_id) +{ + struct rte_eventdev *eventdev; + char eventdev_name[RTE_EVENTDEV_NAME_MAX_LEN]; + + /* Create a unique device name */ + if (skeleton_create_unique_device_name(eventdev_name, + RTE_EVENTDEV_NAME_MAX_LEN) != 0) { + PMD_DRV_ERR("Failed to create unique eventdev name"); + return -EINVAL; + } + + eventdev = rte_event_pmd_vdev_init(eventdev_name, + sizeof(struct skeleton_eventdev), socket_id); + if (eventdev == NULL) { + PMD_DRV_ERR("Failed to create eventdev vdev"); + goto fail; + } + + eventdev->dev_ops = &skeleton_eventdev_ops; + eventdev->schedule = NULL; + eventdev->enqueue = skeleton_eventdev_enqueue; + eventdev->enqueue_burst = skeleton_eventdev_enqueue_burst; + eventdev->dequeue = skeleton_eventdev_dequeue; + eventdev->dequeue_burst = skeleton_eventdev_dequeue_burst; + + return 0; +fail: + return -EFAULT; +} + +static int +skeleton_eventdev_probe(const char *name, __rte_unused const char *input_args) +{ + RTE_LOG(INFO, PMD, "Initializing %s on NUMA node %d", name, + rte_socket_id()); + return skeleton_eventdev_create(rte_socket_id()); +} + +static int +skeleton_eventdev_remove(const char *name) +{ + if (name == NULL) + return -EINVAL; + + PMD_DRV_LOG(INFO, "Closing %s on NUMA node %d", name, rte_socket_id()); + + return 0; +} + +static struct rte_vdev_driver vdev_eventdev_skeleton_pmd = { + .probe = skeleton_eventdev_probe, + .remove = skeleton_eventdev_remove +}; + +RTE_PMD_REGISTER_VDEV(EVENTDEV_NAME_SKELETON_PMD, vdev_eventdev_skeleton_pmd); diff --git a/drivers/event/skeleton/skeleton_eventdev.h b/drivers/event/skeleton/skeleton_eventdev.h new file mode 100644 index 0000000..016cdcd --- /dev/null +++ b/drivers/event/skeleton/skeleton_eventdev.h @@ -0,0 +1,72 @@ +/* + * BSD LICENSE + * + * Copyright (C) Cavium networks Ltd. 2016. + * + * 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 Cavium networks nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * 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 + * OWNER 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 __SKELETON_EVENTDEV_H__ +#define __SKELETON_EVENTDEV_H__ + +#include + +#ifdef RTE_LIBRTE_PMD_SKELETON_EVENTDEV_DEBUG +#define PMD_DRV_LOG(level, fmt, args...) \ + RTE_LOG(level, PMD, "%s(): " fmt "\n", __func__, ## args) +#define PMD_DRV_FUNC_TRACE() PMD_DRV_LOG(DEBUG, ">>") +#else +#define PMD_DRV_LOG(level, fmt, args...) do { } while (0) +#define PMD_DRV_FUNC_TRACE() do { } while (0) +#endif + +#define PMD_DRV_ERR(fmt, args...) \ + RTE_LOG(ERR, PMD, "%s(): " fmt "\n", __func__, ## args) + +struct skeleton_eventdev { + uintptr_t reg_base; + uint16_t device_id; + uint16_t vendor_id; + uint16_t subsystem_device_id; + uint16_t subsystem_vendor_id; +} __rte_cache_aligned; + +struct skeleton_queue { + uint8_t queue_id; +} __rte_cache_aligned; + +struct skeleton_port { + uint8_t port_id; +} __rte_cache_aligned; + +static inline struct skeleton_eventdev * +skeleton_pmd_priv(const struct rte_eventdev *eventdev) +{ + return eventdev->data->dev_private; +} + +#endif /* __SKELETON_EVENTDEV_H__ */ diff --git a/mk/rte.app.mk b/mk/rte.app.mk index 716725a..8341c13 100644 --- a/mk/rte.app.mk +++ b/mk/rte.app.mk @@ -148,6 +148,10 @@ _LDLIBS-$(CONFIG_RTE_LIBRTE_PMD_ZUC) += -lrte_pmd_zuc _LDLIBS-$(CONFIG_RTE_LIBRTE_PMD_ZUC) += -L$(LIBSSO_ZUC_PATH)/build -lsso_zuc endif # CONFIG_RTE_LIBRTE_CRYPTODEV +ifeq ($(CONFIG_RTE_LIBRTE_EVENTDEV),y) +_LDLIBS-$(CONFIG_RTE_LIBRTE_PMD_SKELETON_EVENTDEV) += -lrte_pmd_skeleton_event +endif # CONFIG_RTE_LIBRTE_EVENTDEV + endif # !CONFIG_RTE_BUILD_SHARED_LIBS _LDLIBS-y += --no-whole-archive