From patchwork Thu Sep 13 06:08:37 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Gagandeep Singh X-Patchwork-Id: 44637 X-Patchwork-Delegate: gakhil@marvell.com Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 4A9F84F9B; Thu, 13 Sep 2018 08:09:29 +0200 (CEST) Received: from EUR02-VE1-obe.outbound.protection.outlook.com (mail-eopbgr20044.outbound.protection.outlook.com [40.107.2.44]) by dpdk.org (Postfix) with ESMTP id 20F8A4CA1 for ; Thu, 13 Sep 2018 08:09:26 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=XyrAPlMFq5VcsOBGaS0p4ZVj6Ka1TxZ5YD3hTEtjDOw=; b=xJ021AJPQh4I6wgMpKkQuqGkDFV9sGUHwpVTngp2aUuZ8YaWSLPlTvmwUvb+L8gN5/YVzz+3UJLBM5JStX0gMzgY3Ghu8sxtqMXKwN+AiH0Z/3CFTtXZkty1AA+d6CZKXJj9L/AkD5+Tlvy6s4HWt0zRbkWfuXlD2KljkMK3UdE= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=G.Singh@nxp.com; Received: from Tophie.ap.freescale.net (14.142.187.166) by HE1PR04MB1529.eurprd04.prod.outlook.com (2a01:111:e400:59a8::19) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1143.15; Thu, 13 Sep 2018 06:09:23 +0000 From: Gagandeep Singh To: dev@dpdk.org, akhil.goyal@nxp.com Cc: Hemant Agrawal Date: Thu, 13 Sep 2018 11:38:37 +0530 Message-Id: <20180913060846.29930-2-g.singh@nxp.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20180913060846.29930-1-g.singh@nxp.com> References: <20180913060846.29930-1-g.singh@nxp.com> MIME-Version: 1.0 X-Originating-IP: [14.142.187.166] X-ClientProxiedBy: BM1PR01CA0095.INDPRD01.PROD.OUTLOOK.COM (2603:1096:b00::11) To HE1PR04MB1529.eurprd04.prod.outlook.com (2a01:111:e400:59a8::19) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 72c4968a-9a66-45b2-5c78-08d6193f7415 X-MS-Office365-Filtering-HT: Tenant X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989137)(4534165)(7168020)(4627221)(201703031133081)(201702281549075)(8990107)(5600074)(711020)(4618075)(2017052603328)(7153060)(7193020); SRVR:HE1PR04MB1529; X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 3:hfR3r63P3q4yZ2LNoTJWiNJB9HBvjlC/m6nR0JCWt8/2/XbXuq+VdG7WmME7qsrV9NTF5dm0IMen1Nt34QN2YXQCUq19n56uatsqNDaXzHWLkrnyU/2J3WX+uyIjHfLP2muCnA1bgaBv0MNo7BDoHPITmJcFy2RUvfMG0OALzEK210xY3M7Iq0l1voDOF88DNT2DPlH91KZpV3uFi1J05pSUkC8oloZkdcmOJ64z8yhGHZ8dMZNEqIve0XU+Z8dG; 25:Rr1BJeElTNCjGVH1paiakjkTQoby1OUdTFr1k1EdzQdHiK2OpmjR5DFxJdvhqg/4wXeLDr6kzsebslFPmJyuxNFKIB8826n+01WCv1T831GVkrzsBzLT9nB3ghISe63e31XL48cl59BrgqunKdDAw+xzNDBm3qqfaA/G9VcgCEFuQFi1ys/r4kjNQW/vpcfEjorU0Hj1OBz26dfOTJR7ZjU6DIoNT/Jhjp+U5STYCUYzPTbuDUiMMcbjw6v8T3LlJKu0z2eQYaH3/zL/cooM91/Z1eccImptxsvWoFfIEAYxQsL16cQDp8+8KTKXeCcIlObKy13CFoAg9sphIO7fAQ==; 31:bPEvxNQzIy3sTCUQWcsD7lbPKrtRqFkljT3V9mNfXBkC2ZLIxDNl4+lNwdiFOA768SC2zwpOsblo09OZYYja9Mr4zEobxSZ2S5FBJS+BMp6qXPxVuwgFUW6ShWC8YAQCavdfAB2gd66qx3/Jw4tdie9xGQks8kVRDImxE4C6l21QCpAOXbCx9lTwq/rfujCIVrBRdvR1rqG1ekMAJK3mn3B+YIS/yn7LnxByzOWv9Is= X-MS-TrafficTypeDiagnostic: HE1PR04MB1529: X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 20:ZAoAZjePpjCr5YpCEtGP29V7iVfxhgpX6Qab2NnswbPA0kSVUoK76V1TkQxGIXHyP9LAAo1KcmfHrMX70ewdniq4PHL5aGiGnUJNI6kVCgQKAU86ovN6ZK76XYG+nLIn7MaIB8BycZs/L6wcYlKUF1cby72olRvUggzDxQYJeogEE9VgLDmQAeQh95LbhOVmDoKZ0EkMGdNasHXXeAa3ZRmnSkNkFJ2JBtFwEcrL3rArTNarZd2dmfbVOQEjMquZ2mDK/bCD6KpIb8XmMkffeG49Bem2kvQonUmzIfc7EICA/VvfnxhVenYNcMbuCFSfVni9czPtnYzogPc7vnpMv6kzxM2u0RqSQtveJDAPRmE54wniO67EDu6p0MI32jLYPZvSLaZZikeGqfm6KwdNrO7C9ON5abR4w4q1CeCQIBldqPvYIDxizJ78Kchf0kreCmGrnIgL+WKFgtFnkHgdDyLN7ui3qpk1P7pOqivjDvjg1acCnJhS5Rz9R8/Rk9sQ X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(278428928389397)(192374486261705)(35073007944872)(185117386973197)(264314650089876); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(5005006)(8121501046)(823301075)(3231311)(944501410)(52105095)(3002001)(93006095)(93001095)(10201501046)(6055026)(149027)(150027)(6041310)(20161123558120)(20161123562045)(20161123560045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123564045)(201708071742011)(7699050); SRVR:HE1PR04MB1529; BCL:0; PCL:0; RULEID:; SRVR:HE1PR04MB1529; X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 4:JVg5KvYEU4TSlFlG6PZplSQcFzRYS1SgC5A6Bctah9IO2s8msPZ/ExiY90LQqUP/3XQkODDo0NZQKxf0xlOP6IwrJ8PBT8g76RsPEFNsiFuWbbl5vPoet0sYWGT8zzN2MzGUsuFhbmCBOaAJPNmr14mkkp7IipYkMd9tEO24s585kM+ykvjQr0RnJSYY7fBkjjj5PBoL/ZSezo4GULhKz+uhyAkHVqAJ7T3a9gNr9gkBP3WuDnxAj/UaMzwn6nBe5FGUkpfBYP73af0R8iIAWtpm2Ji6Ue8SPatTRvhrvSI+9UVfa4K4Je7cF+PHmSTJPtvGgVlrg8685bV6AvC88Kl7pTJCSOOQ99su5wg36fjdNnn0V2AgjPJniYNAe3sewele02XUlsV2iPGhbGt9r3cNvr092H/ZHF+cFUeDiZhpjr/3iVYnKca3DWC71fzDmt4RgTmYFB2ZZhVIODN+8w== X-Forefront-PRVS: 07943272E1 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(366004)(376002)(39860400002)(136003)(346002)(396003)(189003)(199004)(2906002)(6506007)(386003)(5009440100003)(6486002)(6512007)(6306002)(52116002)(23676004)(486006)(2616005)(68736007)(956004)(53936002)(2870700001)(476003)(446003)(11346002)(305945005)(26005)(7736002)(55236004)(76176011)(186003)(16526019)(50226002)(478600001)(47776003)(1076002)(3846002)(6116002)(105586002)(106356001)(25786009)(14444005)(50466002)(5660300001)(36756003)(72206003)(66066001)(316002)(97736004)(8936002)(81166006)(4326008)(8676002)(86362001)(6636002)(6666003)(81156014)(110426005); DIR:OUT; SFP:1101; SCL:1; SRVR:HE1PR04MB1529; H:Tophie.ap.freescale.net; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: nxp.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?utf-8?q?1=3BHE1PR04MB1529=3B23=3AUztw?= =?utf-8?q?Zmi6PSx3oz1NYgOXeWcFMsXYy+aRJW6CUldG2uNgHwD37bssTPUsv3Zp?= =?utf-8?q?+WFf/pbdtWh1uJXbmc1/Vd6oVqS+LI3YPrF+BXoNpQs6qfSN5HVfWgow?= =?utf-8?q?e6qhxrD/L3h2v8Med8q1vw+xqOPxd41a/6gmb4HsWEFPKXqthCjFftjj?= =?utf-8?q?dRDn6r2QQo4WK4snHfF9WFbKiZYJRvBkVsG1kluWTca+LpNdZLlHHI4L?= =?utf-8?q?qoemB6K0Ssie/M0ljlqPmRA7d9HnO79y3KcgWWlsy5lGfUchA/tkKjlC?= =?utf-8?q?Z3riKS3UKiioFwsiXxzaSrMd8ALIPOPlQiI8cE2ap43HyizOezuPFRW8?= =?utf-8?q?sGMoXcc9RHOAXJT0ZzMj0NLYjohdnAfirxF5Jk0NdStTdMcwG/xp0j72?= =?utf-8?q?R+7VTg3B376h05B+Z0ecHilxooJnx9M6TGIUSc9bqx54Lc1Mq4zQbcHT?= =?utf-8?q?dOX1BD2niSbheiS2FM2XPwfQDk/MWQI4JofdtyO1oLA7Odmias05Yj4v?= =?utf-8?q?gmkgZWXXQ4WRzJgkg3FJJQZJ5Vi09zw3N/VLDyFMrbNIv2PytOrAGNVf?= =?utf-8?q?C/iyTmdEYAjdqWBP+7Bh3HuDQ6Ol2oCKoJt/Aqmd6eOcRZLgiSrRHLP8?= =?utf-8?q?U4AkxcibYSFx4g+VBzWEq5aq6cQeKZlDtAX0rp4hGIZc8inPJeimldTe?= =?utf-8?q?/sQVS0idmnpFgG6zhjdAJGgsUSZyV7xXYV7c6hwpNCM8ojykNInzvRfF?= =?utf-8?q?BbWAVzjdfCY4Ih/Nr9fmmBw/ys2HmMBY5dlMOtWrzKakBOUBs/uxWYGK?= =?utf-8?q?Lfx4xNzpUtYS//zJlqfhh4UzgylDJ1YOvxDM0LDXq4fo9BrljVitsnD8?= =?utf-8?q?LqXvtwgXmx+1PK/NOFSLsTbp4E2NvFVP0gNY1wvJ6Gxl9AmQkguXvxx4?= =?utf-8?q?Vuv3/KcK1IUPEv8sf+JW5RnSZS+v3nyl0yGFpik35b+0oXuZ+fQBdfq5?= =?utf-8?q?MZ5XBZjqgm6hSfhoi+jeK8o7xjpGNDQ7QqBcCsNgO3JFLzfv0urC3NQ6?= =?utf-8?q?zEi0pJmGuUZWJlEJDpwQuQ99DeCHmaA0NS5FokV6YWD0NR2Cyyk0Avb3?= =?utf-8?q?cGRlVKX02OHp3F2s+aH9zcGhcoAPVbBYxbqCjIbzgozMa5UNgajPBPKx?= =?utf-8?q?Sd9qYl9noPgo+5voRjuGVrIIh3r+F/9G4YsFJ+PAjeELF46mNmlIXHtL?= =?utf-8?q?cnKV2UOP1IULCxIaIiBsHN1iWvLpxvDZXrqYY/mBW91ev4Ug9zX/Gexq?= =?utf-8?q?tmW/heMKlkk562qTevnEPOlJri9JmxhrgJAulBmgb0i1tGIEJxRhEScw?= =?utf-8?q?ugayDILa2uCb2KZri0dyMv4IeD1owCA=3D?= X-Microsoft-Antispam-Message-Info: SrtTfdnbLI604orCjX44xTdmCcZTzN+6RQ7MPW7MIiyhxlISYEJQlH+uurzz66NoUhMcu+FxQHymA0LayqnclBikmMHojwHpt2WXlvlxg4IukeZfe6STz4APi5vtzKWnYuK/gIFW4vU2vllfUK1mJBXngqWdZyKF/edB94ZhYnvyU1cG1QlEn8mSX41r2z2SN72XpTP63cAF66duVbmlPmXRa83Gmz3f8bnAcejLYU3WLBoP7gfu8YpTJL9sqlH1saK7t/pkU79J++E1xPoMK4UrQlsxCxePeEmzN70YZqvXHROfkBszMQs9DyP2m4GQetotKdpdg5vcUhFruJ22JxFhT2UJq6QyxmrKskaG7HA= X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 6:skBQw56ce0TLDtf+ayAUG2KtlbJUVsY/VIF4EXwQkx7L0nuAxM2hEqf6JoVv2OTK/3VKgSAvAYEhoO27ULAUbMN/QZZYVnYiis4uhiZFwjv/axi+d9uNh6vv/iDxqPCei27JUP6jHWQZunlVVXg3ekv/sLq6y+44DFKb0vlP7nohYj4qo4VuGzgaZ70bGWQRpM+k3vOQJaXv/qnwagi6LPmXEJ4NnWM7IxqtZAsLcJNqPY5YXOb95FkKvy6Xf4S3CXQn4w4IdQjPGAz0p5WTE6E12rougTKEcVuxcCi0S5M5u0MnEVs3bAaO1DhNB9GNVI6c5m8j9B63RN8dqdeLD2j+ZtOxHRH9L51mVt8GsNAiN8YTF6wJtsAg5s+9ZjCnd841hBOUyFN1uFLpfEAdDoSPpb52huOFmzpvyYTzLls0AfjyaIXmgU2NT3QoIWMyqH5mLXEHLoOkELXDChgRgw==; 5:aandzPSbC6ezG3g+nqULuK5UfQuGIF56+SK7Xr9Xb913yRDcvkmiESBP4ENTxK7scwwpPzOdk74HORqbO05MeUvl+uB+yCFn8qrVD91otRhgZL6x0MEmsIcIXevXQN3udy1LfgGUYS6ZXuX6JyhNoKrauyMK9HRTHifgRrPPlxA=; 7:sEIyNMVCEdQT9VT+faqt/kdobGrDFv3CPvSMYPp9A9OPwYK078NUCOlqcYh2NWwimoNESy1Bp7pYtjGgh77UG2AmGz+ootepveFL1/FROisyiZXXF5A1RiTmHMyTvpkc5zlDZ7nNdVrssM5fv79hhD+8a0O4dp9o3lxKQVFvBj+XiPeBaSZYRW/eUK4pj/SYZ5zhg27rGSWyLcFeIt1nnkHcDE3Q5OtMPyJO+CNLeRDo6m8pLXKfLmBYansT4Mhs SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 13 Sep 2018 06:09:23.0694 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 72c4968a-9a66-45b2-5c78-08d6193f7415 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-Transport-CrossTenantHeadersStamped: HE1PR04MB1529 Subject: [dpdk-dev] [PATCH 01/10] doc: add caam jr cryptodev details 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" From: Hemant Agrawal Signed-off-by: Hemant Agrawal --- doc/guides/cryptodevs/caam_jr.rst | 159 ++++++++++++++++++++++++++++++ doc/guides/cryptodevs/index.rst | 1 + 2 files changed, 160 insertions(+) create mode 100644 doc/guides/cryptodevs/caam_jr.rst diff --git a/doc/guides/cryptodevs/caam_jr.rst b/doc/guides/cryptodevs/caam_jr.rst new file mode 100644 index 000000000..0ee501506 --- /dev/null +++ b/doc/guides/cryptodevs/caam_jr.rst @@ -0,0 +1,159 @@ +.. SPDX-License-Identifier: BSD-3-Clause + Copyright 2017 NXP + + +NXP CAAM JOB RING (caam_jr) +=========================== + +The caam_jr PMD provides poll mode crypto driver support for NXP SEC 4.x+ (CAAM) +hardware accelerator. More information is available at: + +`NXP Cryptographic Acceleration Technology `_. + +Architecture +------------ + +SEC is the SOC's security engine, which serves as NXP's latest cryptographic +acceleration and offloading hardware. It combines functions previously +implemented in separate modules to create a modular and scalable acceleration +and assurance engine. It also implements block encryption algorithms, stream +cipher algorithms, hashing algorithms, public key algorithms, run-time +integrity checking, and a hardware random number generator. SEC performs +higher-level cryptographic operations than previous NXP cryptographic +accelerators. This provides significant improvement to system level performance. + +SEC HW accelerator above 4.x+ version are also known as CAAM. + +caam_jr PMD is one of DPAA drivers which uses uio interface to interact with +Linux kernel for configure and destroy the device instance (ring). + + +Implementation +-------------- + +SEC provides platform assurance by working with SecMon, which is a companion +logic block that tracks the security state of the SOC. SEC is programmed by +means of descriptors (not to be confused with frame descriptors (FDs)) that +indicate the operations to be performed and link to the message and +associated data. SEC incorporates two DMA engines to fetch the descriptors, +read the message data, and write the results of the operations. The DMA +engine provides a scatter/gather capability so that SEC can read and write +data scattered in memory. SEC may be configured by means of software for +dynamic changes in byte ordering. The default configuration for this version +of SEC is little-endian mode. + +Note that one physical Job Ring represent one caam_jr device. + +Features +-------- + +The CAAM_JR PMD has support for: + +Cipher algorithms: + +* ``RTE_CRYPTO_CIPHER_3DES_CBC`` +* ``RTE_CRYPTO_CIPHER_AES128_CBC`` +* ``RTE_CRYPTO_CIPHER_AES192_CBC`` +* ``RTE_CRYPTO_CIPHER_AES256_CBC`` +* ``RTE_CRYPTO_CIPHER_AES128_CTR`` +* ``RTE_CRYPTO_CIPHER_AES192_CTR`` +* ``RTE_CRYPTO_CIPHER_AES256_CTR`` + +Hash algorithms: + +* ``RTE_CRYPTO_AUTH_SHA1_HMAC`` +* ``RTE_CRYPTO_AUTH_SHA224_HMAC`` +* ``RTE_CRYPTO_AUTH_SHA256_HMAC`` +* ``RTE_CRYPTO_AUTH_SHA384_HMAC`` +* ``RTE_CRYPTO_AUTH_SHA512_HMAC`` +* ``RTE_CRYPTO_AUTH_MD5_HMAC`` + +AEAD algorithms: + +* ``RTE_CRYPTO_AEAD_AES_GCM`` + +Supported DPAA SoCs +-------------------- + +* LS1046A/LS1026A +* LS1043A/LS1023A +* LS1028A +* LS1012A + +Limitations +----------- + +* Hash followed by Cipher mode is not supported +* Only supports the session-oriented API implementation (session-less APIs are not supported). + +Prerequisites +------------- + +caam_jr driver has following dependencies are not part of DPDK and must be installed separately: + +* **NXP Linux SDK** + + NXP Linux software development kit (SDK) includes support for the family + of QorIQ® ARM-Architecture-based system on chip (SoC) processors + and corresponding boards. + + It includes the Linux board support packages (BSPs) for NXP SoCs, + a fully operational tool chain, kernel and board specific modules. + + SDK and related information can be obtained from: `NXP QorIQ SDK `_. + +Currently supported by DPDK: + +* NXP SDK **18.09+**. +* Supported architectures: **arm64 LE**. + +* Follow the DPDK :ref:`Getting Started Guide for Linux ` to setup the basic DPDK environment. + +Pre-Installation Configuration +------------------------------ + +Config File Options +~~~~~~~~~~~~~~~~~~~ + +The following options can be modified in the ``config`` file +to enable caam_jr PMD. + +Please note that enabling debugging options may affect system performance. + +* ``CONFIG_RTE_LIBRTE_PMD_CAAM_JR`` (default ``n``) + By default it is only enabled in common_armv8a_linuxapp config. + Toggle compilation of the ``librte_pmd_caam_jr`` driver. + +* ``CONFIG_RTE_LIBRTE_PMD_CAAM_JR_BE`` (default ``n``) + By default it is disabled. + It can be used when the underlying hardware supports the CAAM in BE mode. + e.g. LS1043A, LS1046A supports CAAM in BE mode. + +* ``CONFIG_RTE_LIBRTE_PMD_CAAM_JR_DEBUG`` (default ``n``) + By default it is disabled. + It can be used enabled debug mode. + +* ``CONFIG_RTE_CAAM_JR_PMD_MAX_NB_SESSIONS`` + By default it is set as 2048 in common_base config. + It indicates Number of sessions to create in the session memory pool + on a single caam_jr device. + + +Installations +------------- +To compile the caam_jr PMD for Linux arm64 gcc target, run the +following ``make`` command: + +.. code-block:: console + + cd + make config T=arm64-armv8a-linuxapp-gcc install + +Enabling logs +------------- + +For enabling logs, use the following EAL parameter: + +.. code-block:: console + + ./your_crypto_application --log-level=pmd.crypto.caam, diff --git a/doc/guides/cryptodevs/index.rst b/doc/guides/cryptodevs/index.rst index e9928a4e2..7dddeec8a 100644 --- a/doc/guides/cryptodevs/index.rst +++ b/doc/guides/cryptodevs/index.rst @@ -13,6 +13,7 @@ Crypto Device Drivers aesni_mb aesni_gcm armv8 + caam_jr ccp dpaa2_sec dpaa_sec From patchwork Thu Sep 13 06:08:38 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Gagandeep Singh X-Patchwork-Id: 44638 X-Patchwork-Delegate: gakhil@marvell.com Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 9EABE568A; Thu, 13 Sep 2018 08:09:31 +0200 (CEST) Received: from EUR02-VE1-obe.outbound.protection.outlook.com (mail-eopbgr20042.outbound.protection.outlook.com [40.107.2.42]) by dpdk.org (Postfix) with ESMTP id AB0D04F91 for ; Thu, 13 Sep 2018 08:09:27 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=rIO+WtYBx6ydrKeWr2e3leiSAbpnWm4rYH/1lhko6xk=; b=BEH1sHvJqG/4zKyhQuMxllwsl+weJ2Nw7R4FKOZcfhHNHbSOzLjoF+LgBgIcBp/lgghcD4hgxHOKYNQKQDwXVPYmT3jTNiOMXNamEa2UEPm9l17+/1MlFBU/Je9AiLJ7cEVx2XdsSrpqQdNY4ykqzxh9gjBsyYcJcjjpQ921Nks= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=G.Singh@nxp.com; Received: from Tophie.ap.freescale.net (14.142.187.166) by HE1PR04MB1529.eurprd04.prod.outlook.com (2a01:111:e400:59a8::19) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1143.15; Thu, 13 Sep 2018 06:09:24 +0000 From: Gagandeep Singh To: dev@dpdk.org, akhil.goyal@nxp.com Cc: Hemant Agrawal , Gagandeep Singh Date: Thu, 13 Sep 2018 11:38:38 +0530 Message-Id: <20180913060846.29930-3-g.singh@nxp.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20180913060846.29930-1-g.singh@nxp.com> References: <20180913060846.29930-1-g.singh@nxp.com> MIME-Version: 1.0 X-Originating-IP: [14.142.187.166] X-ClientProxiedBy: BM1PR01CA0095.INDPRD01.PROD.OUTLOOK.COM (2603:1096:b00::11) To HE1PR04MB1529.eurprd04.prod.outlook.com (2a01:111:e400:59a8::19) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: b5dde0c4-dbd8-44a2-b6a6-08d6193f750f X-MS-Office365-Filtering-HT: Tenant X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989137)(4534165)(7168020)(4627221)(201703031133081)(201702281549075)(8990107)(5600074)(711020)(4618075)(2017052603328)(7153060)(7193020); SRVR:HE1PR04MB1529; X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 3:JXW4Bi0cSVDIVUH1/h0hll4+6Lsemgr0j7kgDD9REw/K4yy8rMHbY5MRkswU0J7pN7hlScDxcDTcJuMujNBSMG6PguTFVqNQlBnYFfNZKaa8e13uNw8AvQA6+49hX22qPtjJw99vG3yMfhXhwxXmXsUJOfVzJdWp5yZPqmtviA/H1oqbfGqRUAnwDXpb7l0gL32JrNWMXd0AKXynekhoPr7fCGwTdr9DqJJLH67cDlx5uFjqxN9hDMV8J9W+YlGx; 25:kKpf/y19jgDz9z8JPNvyCeNIThiLfGMR93uSJb+z8va+bcap7QmfifurnbPU9v4ggwUD/SvhL4H+FtZNJc3yqvfjO1/KKwG1Udn1/DDmJu+JuoX3ZDDke1HbTVJbGI5VW+bjcn/A4mXwI9Z3ppAU68LxAIh9ymByQoqVHrfOhD8KW7VqqQGViH3qBSBgR/w6bR50vqZ5+/dO4/FRo+2TP8AViwy+wps4FUkqpxaizq0eu6M2BiIbGYf3rOG1pLRkh+gBD6p45nu3U/VV6Z6NAjuyqftYlZCAl13RPeLBv2rRV9yQ6R4PTppwhBEkeI8JqxeBGVhN285SKUM44KEuDw==; 31:e9h/MeE6Xdo2TEZLEb9+Dg8/MfjyY9N/qQ4yffoxmH9QRYPxprIxzcvMDF3/yOVAU98f7bR0/vgXMqaW+vHt1lLNMqUe1l08eGuLFheEvntxCDwYm5FAdWbaIpq2hCW9J2Zzm+URolBVHzhr16r4VWrImQ22Lbcq8eNONrgNPFnLbD2CC6MeAhKaBmxudOhcy7QUDnZO2QOskhrOQUWctg3wg7AlBdHHRhUp2+UAG+Q= X-MS-TrafficTypeDiagnostic: HE1PR04MB1529: X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 20:D3vDxZq9BQggsRgQVUjvoLnA3spbyfZbS2NNGII36Exsg4wQKiN5WdfNt0ff9t64OlNHp6vi9dqa5WYPbeizGAjR7MMbm2iNXk7R9e+KLfVsoSZfuoU1YxyyRh+jEPCC/HUCYKc8HTxYOIM+xbakQLZIZlFrLApnHlqZ/f7YXXIR92q01BANwqWdTpOZTzBorX6Sje7iVsc9QEEl7ZvH8USGTbLNjHTwo6DViaR/1ALZMBc+r4kCMxoIFTSYL9/08T8s8A3jAxal0SbVjSH4X26aW2z6aZBCxDu/EJre+CcvBUiOoCS2R9ojO+tduCM2K2EVYTMZFk1usWK2V+uaI0yC4Dh0bjh/0KOR0jmE+znwkTH0hhXu2rEIRChE++jUiTyqTeu2HGMoPsp5g8bPlB/R8JVdqCrluXjGbR4LLi7qgJWsde9WN+BAbd5rf8QYctKGEULZKcjvFq1oaygzalKjQlWQiVJqARKy5vthl4DoSBgBfqucdInxspPmsiFB; 4:932pCe0FxTgovKSyPy7Fn23shr4I+ZTj/2YHs16vJnFsQ15W667hTyRjx8Q/3LMqhFBNPxncAEKIX7GjBCGl/d5JG9k2i7PFLLo04y/sn6JtKXlcplHcgee70SldGaFLPEXhhuCZqIBMMUq3q7eZEfjnHk7ypdE/f9f02uZem8oH0mdLBMVFXn1ous70cXK9ePwibW2yTOD/2fQN5GPL4niAES9VjeN9O/HwvaBMdVAAuubHuHT2Xvc8OdN+TF2WIBaTojqtqPaZPn+I65k8Y8tV+9tSZlJaJzioiPkgi2KT7n3S7imhoRJWdr8/M+05BazWCRc8haI8MDGbkltykYU5at2YlPhPEMRc454Ziw4= X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(192374486261705)(185117386973197); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(5005006)(8121501046)(823301075)(3231311)(944501410)(52105095)(3002001)(93006095)(93001095)(10201501046)(6055026)(149027)(150027)(6041310)(20161123558120)(20161123562045)(20161123560045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123564045)(201708071742011)(7699050); SRVR:HE1PR04MB1529; BCL:0; PCL:0; RULEID:; SRVR:HE1PR04MB1529; X-Forefront-PRVS: 07943272E1 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(366004)(376002)(39860400002)(136003)(346002)(396003)(189003)(199004)(2906002)(6506007)(386003)(5009440100003)(6486002)(51416003)(6512007)(52116002)(486006)(2616005)(68736007)(956004)(53936002)(476003)(446003)(11346002)(305945005)(26005)(7736002)(55236004)(76176011)(186003)(16526019)(50226002)(478600001)(47776003)(1076002)(3846002)(6116002)(48376002)(105586002)(106356001)(25786009)(14444005)(50466002)(5660300001)(36756003)(72206003)(66066001)(316002)(97736004)(8936002)(81166006)(4326008)(8676002)(86362001)(6636002)(6666003)(575784001)(54906003)(81156014)(16586007)(110426005); DIR:OUT; SFP:1101; SCL:1; SRVR:HE1PR04MB1529; H:Tophie.ap.freescale.net; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: nxp.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; HE1PR04MB1529; 23:7t1VZB/dXw97kg8dwQnwsgJ7V9IFUxEe5M20347XU?= 4nknbS1vyr4+elhP8UFsIHV5hgMGfZqwsRWsgSxuQrvXUdLchDbmb2khfLewm5a2PDIRmkNPkCWckim4V9fg8M2Z/jJ+aJwYH2/BFne/Pvj6vDutJjKxk0vHULW4F+EyZNQa1tqRW/5NISNxFOEIyGz12USYK5wUR8o7KntZOabqzo/toONmkuKrbTd9D4qiROTOT56ZiOyL6DLrK+V7kBYXbzN+vmQ/NwIjvTZTxvstkv1aFqQYBzL8qaOcRIHBTjhwwf84CFP7JxXjNZCI7Pj0lgwU/ge0rK5noB6rmj+aN53qOKgTeeO78WcfSKCKEH5gA10h/vSrFZ2rMY2VkI+71YqFF23sM6ZGxBEJXUN1JipkDJJuGaXPAurr8Xr2KgRj46tLoH4JardHy0akaq7TA9uGxcfUVf7Vs5DDd9LsqPAckT8sxDqny6t9czSNzqOTnexbUIVCkjk2Q0MQ4yH2wmKJ0TUqcI9QsSWlTM36qFAI/sZMojAA5xZI2EuxH/m0Umk9AAgAiOu53glt/aBehuh9rTzysPUcmFlg19WfxNo6LSlEzfmLu5OlkTnifFxCDeCZCQzDFmLa+bZk94RRUMJtXKk1lKh4OUOfRcO0hrj/aR0uK/MOvcOv2ozOSfAix6Gvuzck3o86a+0hbbFWvzcMkjDM1iHEskpE5/qkAIoO3BdgelRlXcUdteo9MocBO/HkvHYs6fPrI/XRF1OMRp7yIcAgBe4uXwm9K9yTyBavYZCcek5BKREJNbGUm1Yf8bdDlFZbCpc7e5xG9AoV4wd2ElVFPU+YmKu3E7b6wJbGFaYPVjFjN89hR+QdzRgWoWB1IUXv5AHErMQqVXfq5tts19mlCJvAxzwUgYpfwIEpawUjjLnCpqcQZRWrkwqwni2+sBrkd3wNaQEUp1xdNwMbGBz9AIIygzcusntJagXqXI/HEghOak9zLuPNDFCq1nRykVpu9SgvqFYZwcQASBHAOfoyZ0jsNTyhvJcU3xm9UeQwaWGvC90ktT0QURH+H/q1snZ+wl0OteJNJmw4aPxxNZ58ir/AsfSqmNGqJpHVjABAi1YY3CRC7jwLiHkfCmG8HA5agdRrXgpp7jLXU36PyA9ojp8i5YYXBtE4O48cpeZkpZmXPsgwU1FFBku2dil/Fu5T0IA+2D28Eyfz8tQikrr797TvQsxYhGSiWwEjoLPY/S01b04OpkrGUdn+6frBUEAc9RybxiHSetPoQFgq+KmNYzUTMaoAeLhLe8fdP54EIOBWTc5vFJQDlJfyU2/ajqh8mAb6vlOL8f8Kyb3yUmWDh6EgyCVWtljJg== X-Microsoft-Antispam-Message-Info: fayQIZZ5zBnm5P4ggzaUcc2r5CC6cWEuSc4Bm7RhzzctFojUSODkgV8G868b1FwLW3xNNgR0vpfiEuuK1NBgVqi8xjcJz15TJtoZmCWQyr0MNC+IyFI/oxAIgZfswrwWj/ehI7s9gmuLOBiJlbXyZCjC8bgAPRbXFQ/aw+wfNeHHD8d2H9wPFb27x5Njx/GqeICqxw1BTya4o2cMoE7O5Q89EWQ2gkBoEXFELDuWjPB9dSV7Z8bZIfWhu7klr5XiDu7/kUes8OoO8BwIgZlgm/fsuwXRR3HPXcPTQgsCcsEdDvnYuJhSwGMl9PtwzYFsF7ePOv7mOUIGyFJkGWtrNFWa55iIGYdHY3kP9VlG0f8= X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 6:128HOv2I7eB29VbUkHVcM2PQrcfMzmu7oZ6RER93npryG8Oz3Z0wbmUKkJwx0KLo2bCcwBYDdL89XOLOOJJP0UpjBlzVtbYcySg2K3yW5V/FnLXj/nBd3pVNJoiuYnClH0zV/c8jR2tFpetH7LrjNMUSHXk9xh/bC6WX82ZGCTgBVci06tWUpu8Cb9ZWJ6G0K62cwZXpkw8VgA+aIrtDEidBd23fvsFWtHj/ZCG4zPOcuw+WXN5waAM8UY7tVw7B5AAEFniMWOTVZxxll30c2f2sCqrW2OtH+PLJxFJJZUr0peB0zJJIYaI2ivy/+7//XbfApuc4rm7L3F7oadoH26xATeGr8YchFQfsMEtdYBslxdp7U0enP3iyw0HiZxic8WRhb1VLQKMwOdLbsA/bxIeRRW2u0WTbcDPpAM+OvwMt+rDPfVOtM62EluMVo20OLNuJ5BMJh4QNJy5zrO0Yaw==; 5:9lsF1tSNXlnXB3YKxTJoqsQ1IKRavZETFahPmECv9MF8hPxFCIQ3qT0MbepfogawjgYA9p7hrDZMxfN2cBX4GwhPnhBplSvfTGGSmk0A28ZWr7kiIhASrHYzfxlj8xFqwwBOD0HjW7pgxwsVFcEoAF9zjRe2m7JU5hHW6w1Qk7c=; 7:GiGN7nwm2CUaBJxHczNrLpGQCVSxuok/Liip0ioHuRnRJyVXh2m2nMyxARVAc+0iEmySPq62i5/BO2RX7+uRwkBGg8kZpzTTpRDT8d0CSTbjysuFi4h6dfL0z4AFzOWSSzRy0mBHQ9YK7MTC37cBevaSHzrfBAgVl/3CEAXgS+DXjhADq0JuCZfSUdT4/dE+JHGnvymMCJFp5FH1L7gs72JC+RYgdpO8Rzx5a+YN5s8ldK//KnfhBLyad/+SWd9N SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 13 Sep 2018 06:09:24.5382 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: b5dde0c4-dbd8-44a2-b6a6-08d6193f750f X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-Transport-CrossTenantHeadersStamped: HE1PR04MB1529 Subject: [dpdk-dev] [PATCH 02/10] crypto/caam_jr: introduce basic 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" From: Hemant Agrawal This patch introduces basic support for caam_jr crypto driver. Signed-off-by: Gagandeep Singh Signed-off-by: Hemant Agrawal --- config/common_base | 8 + config/common_linuxapp | 1 + config/defconfig_arm64-dpaa-linuxapp-gcc | 4 + drivers/crypto/Makefile | 1 + drivers/crypto/caam_jr/Makefile | 40 +++++ drivers/crypto/caam_jr/caam_jr.c | 157 ++++++++++++++++++ drivers/crypto/caam_jr/caam_jr_log.h | 42 +++++ drivers/crypto/caam_jr/meson.build | 11 ++ .../caam_jr/rte_pmd_caam_jr_version.map | 4 + drivers/crypto/meson.build | 2 +- 10 files changed, 269 insertions(+), 1 deletion(-) create mode 100644 drivers/crypto/caam_jr/Makefile create mode 100644 drivers/crypto/caam_jr/caam_jr.c create mode 100644 drivers/crypto/caam_jr/caam_jr_log.h create mode 100644 drivers/crypto/caam_jr/meson.build create mode 100644 drivers/crypto/caam_jr/rte_pmd_caam_jr_version.map diff --git a/config/common_base b/config/common_base index 4bcbaf923..a73f063d1 100644 --- a/config/common_base +++ b/config/common_base @@ -479,6 +479,14 @@ CONFIG_RTE_CRYPTO_MAX_DEVS=64 CONFIG_RTE_LIBRTE_PMD_ARMV8_CRYPTO=n CONFIG_RTE_LIBRTE_PMD_ARMV8_CRYPTO_DEBUG=n +# +# Compile NXP CAAM JR crypto Driver +# +CONFIG_RTE_LIBRTE_PMD_CAAM_JR=n +CONFIG_RTE_LIBRTE_PMD_CAAM_JR_BE=n +CONFIG_RTE_LIBRTE_PMD_CAAM_JR_DEBUG=n +CONFIG_RTE_CAAM_JR_PMD_MAX_NB_SESSIONS=2048 + # # Compile NXP DPAA2 crypto sec driver for CAAM HW # diff --git a/config/common_linuxapp b/config/common_linuxapp index 9c5ea9d89..c1c7c4287 100644 --- a/config/common_linuxapp +++ b/config/common_linuxapp @@ -35,6 +35,7 @@ CONFIG_RTE_LIBRTE_DPAA_MEMPOOL=y CONFIG_RTE_LIBRTE_DPAA_PMD=y CONFIG_RTE_LIBRTE_PMD_DPAA_EVENTDEV=y CONFIG_RTE_LIBRTE_PMD_DPAA_SEC=y +CONFIG_RTE_LIBRTE_PMD_CAAM_JR=y # NXP FSLMC BUS and DPAA2 drivers CONFIG_RTE_LIBRTE_FSLMC_BUS=y diff --git a/config/defconfig_arm64-dpaa-linuxapp-gcc b/config/defconfig_arm64-dpaa-linuxapp-gcc index c47aec0a6..e5343f7a9 100644 --- a/config/defconfig_arm64-dpaa-linuxapp-gcc +++ b/config/defconfig_arm64-dpaa-linuxapp-gcc @@ -21,3 +21,7 @@ CONFIG_RTE_PKTMBUF_HEADROOM=128 # NXP DPAA Bus CONFIG_RTE_LIBRTE_DPAA_DEBUG_DRIVER=n CONFIG_RTE_LIBRTE_DPAA_HWDEBUG=n + +# NXP CAAM_JR driver +CONFIG_RTE_LIBRTE_PMD_CAAM_JR=y +CONFIG_RTE_LIBRTE_PMD_CAAM_JR_BE=y diff --git a/drivers/crypto/Makefile b/drivers/crypto/Makefile index c480cbd37..e3711d703 100644 --- a/drivers/crypto/Makefile +++ b/drivers/crypto/Makefile @@ -6,6 +6,7 @@ include $(RTE_SDK)/mk/rte.vars.mk DIRS-$(CONFIG_RTE_LIBRTE_PMD_AESNI_GCM) += aesni_gcm DIRS-$(CONFIG_RTE_LIBRTE_PMD_AESNI_MB) += aesni_mb DIRS-$(CONFIG_RTE_LIBRTE_PMD_ARMV8_CRYPTO) += armv8 +DIRS-$(CONFIG_RTE_LIBRTE_PMD_CAAM_JR) += caam_jr DIRS-$(CONFIG_RTE_LIBRTE_PMD_CCP) += ccp DIRS-$(CONFIG_RTE_LIBRTE_PMD_OPENSSL) += openssl DIRS-$(CONFIG_RTE_LIBRTE_PMD_CRYPTO_SCHEDULER) += scheduler diff --git a/drivers/crypto/caam_jr/Makefile b/drivers/crypto/caam_jr/Makefile new file mode 100644 index 000000000..46d752af7 --- /dev/null +++ b/drivers/crypto/caam_jr/Makefile @@ -0,0 +1,40 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright 2017 NXP + +include $(RTE_SDK)/mk/rte.vars.mk + +# +# library name +# +LIB = librte_pmd_caam_jr.a + +# build flags +CFLAGS += -DALLOW_EXPERIMENTAL_API +CFLAGS += -D _GNU_SOURCE +ifeq ($(CONFIG_RTE_LIBRTE_CAAM_JR_DEBUG),y) +CFLAGS += -O0 -g +CFLAGS += "-Wno-error" +else +CFLAGS += -O3 +CFLAGS += $(WERROR_FLAGS) +endif + +CFLAGS += -I$(RTE_SDK)/drivers/crypto/caam_jr +CFLAGS += -I$(RTE_SDK)/lib/librte_eal/common/include +CFLAGS += -I$(RTE_SDK)/lib/librte_eal/linuxapp/eal + +# versioning export map +EXPORT_MAP := rte_pmd_caam_jr_version.map + +# library version +LIBABIVER := 1 + +# library source files +SRCS-$(CONFIG_RTE_LIBRTE_PMD_CAAM_JR) += caam_jr.c +# library dependencies + +LDLIBS += -lrte_eal -lrte_mbuf -lrte_mempool -lrte_ring +LDLIBS += -lrte_cryptodev +LDLIBS += -lrte_bus_vdev + +include $(RTE_SDK)/mk/rte.lib.mk diff --git a/drivers/crypto/caam_jr/caam_jr.c b/drivers/crypto/caam_jr/caam_jr.c new file mode 100644 index 000000000..68779cba5 --- /dev/null +++ b/drivers/crypto/caam_jr/caam_jr.c @@ -0,0 +1,157 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright 2017-2018 NXP + */ + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#define CRYPTODEV_NAME_CAAM_JR_PMD crypto_caam_jr +static uint8_t cryptodev_driver_id; +int caam_jr_logtype; + + +/* + * @brief Release the resources used by the SEC user space driver. + * + * Reset and release SEC's job rings indicated by the User Application at + * init_job_ring() and free any memory allocated internally. + * Call once during application tear down. + * + * @note In case there are any descriptors in-flight (descriptors received by + * SEC driver for processing and for which no response was yet provided to UA), + * the descriptors are discarded without any notifications to User Application. + * + * @retval ::0 is returned for a successful execution + * @retval ::-1 is returned if SEC driver release is in progress + */ + +static int +caam_jr_dev_uninit(struct rte_cryptodev *dev) +{ + + if (dev == NULL) + return -ENODEV; + + + CAAM_JR_INFO("Closing DPAA_SEC device %s", dev->data->name); + + + return 0; +} + +static int +caam_jr_dev_init(const char *name, + struct rte_vdev_device *vdev, + struct rte_cryptodev_pmd_init_params *init_params) +{ + struct rte_cryptodev *dev; + + PMD_INIT_FUNC_TRACE(); + + dev = rte_cryptodev_pmd_create(name, &vdev->device, init_params); + if (dev == NULL) { + CAAM_JR_ERR("failed to create cryptodev vdev"); + goto cleanup; + } + + dev->driver_id = cryptodev_driver_id; + dev->dev_ops = NULL; + + /* For secondary processes, we don't initialise any further as primary + * has already done this work. Only check we don't need a different + * RX function + */ + if (rte_eal_process_type() != RTE_PROC_PRIMARY) { + CAAM_JR_WARN("Device already init by primary process"); + return 0; + } + + RTE_LOG(INFO, PMD, "%s cryptodev init\n", dev->data->name); + + return 0; + +cleanup: + CAAM_JR_ERR("driver %s: cryptodev_caam_jr_create failed", + init_params->name); + + return -ENXIO; +} + +/** Initialise CAAM JR crypto device */ +static int +cryptodev_caam_jr_probe(struct rte_vdev_device *vdev) +{ + struct rte_cryptodev_pmd_init_params init_params = { + "", + 128, + rte_socket_id(), + RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_QUEUE_PAIRS + }; + const char *name; + const char *input_args; + + name = rte_vdev_device_name(vdev); + if (name == NULL) + return -EINVAL; + + input_args = rte_vdev_device_args(vdev); + rte_cryptodev_pmd_parse_input_args(&init_params, input_args); + + return caam_jr_dev_init(name, vdev, &init_params); +} + +/** Uninitialise CAAM JR crypto device */ +static int +cryptodev_caam_jr_remove(struct rte_vdev_device *vdev) +{ + struct rte_cryptodev *cryptodev; + const char *name; + + name = rte_vdev_device_name(vdev); + if (name == NULL) + return -EINVAL; + + cryptodev = rte_cryptodev_pmd_get_named_dev(name); + if (cryptodev == NULL) + return -ENODEV; + + caam_jr_dev_uninit(cryptodev); + + return rte_cryptodev_pmd_destroy(cryptodev); +} + +static struct rte_vdev_driver cryptodev_caam_jr_drv = { + .probe = cryptodev_caam_jr_probe, + .remove = cryptodev_caam_jr_remove +}; + +static struct cryptodev_driver caam_jr_crypto_drv; + +RTE_PMD_REGISTER_VDEV(CRYPTODEV_NAME_CAAM_JR_PMD, cryptodev_caam_jr_drv); +RTE_PMD_REGISTER_PARAM_STRING(CRYPTODEV_NAME_CAAM_JR_PMD, + "max_nb_queue_pairs=" + "max_nb_sessions=" + "socket_id="); +RTE_PMD_REGISTER_CRYPTO_DRIVER(caam_jr_crypto_drv, cryptodev_caam_jr_drv.driver, + cryptodev_driver_id); + +RTE_INIT(caam_jr_init_log) +{ + caam_jr_logtype = rte_log_register("pmd.crypto.caam"); + if (caam_jr_logtype >= 0) + rte_log_set_level(caam_jr_logtype, RTE_LOG_NOTICE); +} diff --git a/drivers/crypto/caam_jr/caam_jr_log.h b/drivers/crypto/caam_jr/caam_jr_log.h new file mode 100644 index 000000000..106ff07a7 --- /dev/null +++ b/drivers/crypto/caam_jr/caam_jr_log.h @@ -0,0 +1,42 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright 2017-2018 NXP + */ + +#ifndef _CAAM_JR_LOG_H_ +#define _CAAM_JR_LOG_H_ + +#include + +extern int caam_jr_logtype; + +#define CAAM_JR_LOG(level, fmt, args...) \ + rte_log(RTE_LOG_ ## level, caam_jr_logtype, "caam_jr: " \ + fmt "\n", ##args) + +#define CAAM_JR_DEBUG(fmt, args...) \ + rte_log(RTE_LOG_DEBUG, caam_jr_logtype, "caam_jr: %s(): " \ + fmt "\n", __func__, ##args) + +#define PMD_INIT_FUNC_TRACE() CAAM_JR_DEBUG(" >>") + +#define CAAM_JR_INFO(fmt, args...) \ + CAAM_JR_LOG(INFO, fmt, ## args) +#define CAAM_JR_ERR(fmt, args...) \ + CAAM_JR_LOG(ERR, fmt, ## args) +#define CAAM_JR_WARN(fmt, args...) \ + CAAM_JR_LOG(WARNING, fmt, ## args) + +/* DP Logs, toggled out at compile time if level lower than current level */ +#define CAAM_JR_DP_LOG(level, fmt, args...) \ + RTE_LOG_DP(level, PMD, fmt "\n", ## args) + +#define CAAM_JR_DP_DEBUG(fmt, args...) \ + CAAM_JR_DP_LOG(DEBUG, fmt, ## args) +#define CAAM_JR_DP_INFO(fmt, args...) \ + CAAM_JR_DP_LOG(INFO, fmt, ## args) +#define CAAM_JR_DP_WARN(fmt, args...) \ + CAAM_JR_DP_LOG(WARNING, fmt, ## args) +#define CAAM_JR_DP_ERR(fmt, args...) \ + CAAM_JR_DP_LOG(ERR, fmt, ## args) + +#endif /* _CAAM_JR_LOG_H_ */ diff --git a/drivers/crypto/caam_jr/meson.build b/drivers/crypto/caam_jr/meson.build new file mode 100644 index 000000000..3edd0a212 --- /dev/null +++ b/drivers/crypto/caam_jr/meson.build @@ -0,0 +1,11 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright 2018 NXP + +if host_machine.system() != 'linux' + build = false +endif + +deps += ['bus_vdev', 'bus_dpaa', 'security'] +sources = files('caam_jr.c') + +allow_experimental_apis = true diff --git a/drivers/crypto/caam_jr/rte_pmd_caam_jr_version.map b/drivers/crypto/caam_jr/rte_pmd_caam_jr_version.map new file mode 100644 index 000000000..521e51f41 --- /dev/null +++ b/drivers/crypto/caam_jr/rte_pmd_caam_jr_version.map @@ -0,0 +1,4 @@ +DPDK_18.11 { + + local: *; +}; diff --git a/drivers/crypto/meson.build b/drivers/crypto/meson.build index d64ca418b..f4390581c 100644 --- a/drivers/crypto/meson.build +++ b/drivers/crypto/meson.build @@ -1,7 +1,7 @@ # SPDX-License-Identifier: BSD-3-Clause # Copyright(c) 2017 Intel Corporation -drivers = ['ccp', 'dpaa_sec', 'dpaa2_sec', 'mvsam', +drivers = ['caam_jr', 'ccp', 'dpaa_sec', 'dpaa2_sec', 'mvsam', 'null', 'openssl', 'qat', 'virtio'] std_deps = ['cryptodev'] # cryptodev pulls in all other needed deps From patchwork Thu Sep 13 06:08:39 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Gagandeep Singh X-Patchwork-Id: 44639 X-Patchwork-Delegate: gakhil@marvell.com Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 597725688; Thu, 13 Sep 2018 08:09:35 +0200 (CEST) Received: from EUR02-VE1-obe.outbound.protection.outlook.com (mail-eopbgr20074.outbound.protection.outlook.com [40.107.2.74]) by dpdk.org (Postfix) with ESMTP id CDE8F54AE for ; Thu, 13 Sep 2018 08:09:30 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=xVjs5181sEFtJzx7EiH4nU2HTYfRduvqMhWgTMxDiOE=; b=Mm2jtlHMxy/HowGdKuW7iuloxS3Vshi/eEoA4AO29gGp8qWI6jVxCtFdKIWuerxmFf8+1xbcgMQCpLjO7npXvg/6rKzeNKOc4iP8MEV7gdNFu6z3HymOhNLIDh9q8EztsLWWw0bTTO2+Ek3QqllYRtLQ2tIgNlDH7bNOPsOcmYw= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=G.Singh@nxp.com; Received: from Tophie.ap.freescale.net (14.142.187.166) by HE1PR04MB1529.eurprd04.prod.outlook.com (2a01:111:e400:59a8::19) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1143.15; Thu, 13 Sep 2018 06:09:26 +0000 From: Gagandeep Singh To: dev@dpdk.org, akhil.goyal@nxp.com Cc: Hemant Agrawal , Gagandeep Singh Date: Thu, 13 Sep 2018 11:38:39 +0530 Message-Id: <20180913060846.29930-4-g.singh@nxp.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20180913060846.29930-1-g.singh@nxp.com> References: <20180913060846.29930-1-g.singh@nxp.com> MIME-Version: 1.0 X-Originating-IP: [14.142.187.166] X-ClientProxiedBy: BM1PR01CA0095.INDPRD01.PROD.OUTLOOK.COM (2603:1096:b00::11) To HE1PR04MB1529.eurprd04.prod.outlook.com (2a01:111:e400:59a8::19) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 1b4fab3c-6b30-4243-c188-08d6193f761a X-MS-Office365-Filtering-HT: Tenant X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989137)(4534165)(7168020)(4627221)(201703031133081)(201702281549075)(8990107)(5600074)(711020)(4618075)(2017052603328)(7153060)(7193020); SRVR:HE1PR04MB1529; X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 3:fxwqnvHYSXzdYeQlEzFARsQTOzJjfyRs4atx927n9oR1QP/hV01lifPpe/8oCof8y1U21e470kLy+CxfukVVfZKZabIon/1Ap9Nxshe/m4W9cmF1FPjBTf0BCyxYjiEM5aCZ715dpKzn9DHsNwQN326Q1YNy6HLMIh/LeSuBI0Osrz87aeczQqRN8eUn75Wm3ZmYwvvQqsYVV6C37yOSNSi5PguNX/7LgKp3D0hplSzV7sYnSJCmb8Hwx/8L2UoZ; 25:F5DERZgFYZ5UOYYN8qu2jf6z0r38K+gT1nx00hQ7EkasF2HuCmm1r/JTzRr/R5b7Zyn/GofdyxY1b5+10NrbwhrvR1RD9mJQ/GXmYN1qlQWQsx5ZgzuObJOOx5VmsutCb46W9xmEBMiTGgaGu5D+d7LD68ALu8kSSjgc6yLRLcHdzhJTgJywaiUrO2iMCHLHp6pW/Nj/8nw7ibNEIXHZJgLW+QHX5egM/jqO41OHsT0S+a/xrLA6C9A2+lTz1vzXN1Wnflps8Ef1jRUUtltpB0u5iuHvuU8yR8qrD5KKhoDjSg0Pzrf4DYHs0DKPTD9FoUJFbHIRrNrauYztOhcZVw==; 31:9+OjjAR1cPSlEtiVCJpHfqxXFA3sviRaNiM6c5a7YKp+zBw25UagiMiVLuk6emba0oZhy6VHxs8gBdaFxolGHyQQfhgIb5QcW9sTE7WaqtrLJVPS3KdGcGA8L7YRIpP50y3yL5QLIcvZmyfp1LhCHt9BKL6oiROPuIk82V6PT+EXyTKbePHokjBI3uif5RywmmeMNZdn0Jb43e5jryYPSGBNh1/1Mnj9UG8zoTYRDPA= X-MS-TrafficTypeDiagnostic: HE1PR04MB1529: X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 20:/tQVKepZyygmdQgzQjVqZvIWCc+HZIU6kR9k2UvprYT6OW42MM8VsNaWiCJMmcHIP6528T1UKM7ysnuKAS4DHGVAqw2tqUICljdIJHlFI6fZfo6ZCn403PwZ6psQ7paT+tYrhxAmdrSvIHDJ8KFGKPLzG5UqlxmNFT/Dnhzx5FK2S3ZFq6ylzkkTVbfawNKXqErH5yn8oYiXud8ED3+KUgtkAkYlZEZlIr4Jn0eEs9cQV8iOOPNss2liF3e3rO6IQLkhB66+jT94s6ysVGYr5sLj+/edbELLzN8dsXtCrxsqAko9HM1LAoO2h2AOens6feThnPDS0hK/JT8RX4EbqmWYYUL0BCdlDCLnMiefvZX0B9BVfTuW37qkYMxNNW+c3f0gM5J5Ik9r9Rw8wm15O1uUhBiBeXMkKOM39sOgMOf+SBT2HaoNLfpOaH+Fzn/Lbd42NOlBSTYo4KoazsR4vsI17c6LzPHuhVj2h/2qwhdTIEgs5GS20lfaJwKxAkBR; 4:z5U7euP4IrcKmr66UBrhbFBNq1II3a2AT+dOSMXNikR5fXdvprzO0kRIaYJ5lGB0W7ytQYae6tA6ttKLieXqXwyMGGXwaYWmbqvlzr8K/w8UWowB9XIODV0YjS8cALXrXUG3acL7QFZpdZ3bdJh9Um9yu+frBgURG1Kug1/3/R5w6UQntEnx2KzQfk7rTJjrtIHa61acMMxqO+oxW3fEsFRP2rTZkuAoIxGsfxxmxjzEY0o+YQcZyfrQH/kpH/YkBYC6fcz+FK2wJ3N5wwyVY0vLUdpjmUFJ7e1PRytXAlr0BMUzu7XQtHkTIg1dYc0Y7XzxPa2KCb2qe3ABorL2KEPz0ej2hhmW0s2H7t3JLpuEV6DNAd0RixEFqYx9kdEl X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(192374486261705)(185117386973197)(17755550239193); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(5005006)(8121501046)(823301075)(3231311)(944501410)(52105095)(3002001)(93006095)(93001095)(10201501046)(6055026)(149027)(150027)(6041310)(20161123558120)(20161123562045)(20161123560045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123564045)(201708071742011)(7699050); SRVR:HE1PR04MB1529; BCL:0; PCL:0; RULEID:; SRVR:HE1PR04MB1529; X-Forefront-PRVS: 07943272E1 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(366004)(376002)(39860400002)(136003)(346002)(396003)(189003)(199004)(2906002)(6506007)(386003)(5009440100003)(6486002)(51416003)(6512007)(52116002)(16200700003)(486006)(2616005)(53946003)(68736007)(956004)(53936002)(476003)(446003)(11346002)(305945005)(26005)(7736002)(55236004)(76176011)(186003)(16526019)(50226002)(478600001)(47776003)(1076002)(3846002)(6116002)(48376002)(105586002)(106356001)(25786009)(14444005)(50466002)(5660300001)(36756003)(72206003)(66066001)(316002)(97736004)(8936002)(81166006)(4326008)(8676002)(86362001)(6636002)(6666003)(575784001)(54906003)(81156014)(16586007)(110426005)(403724002)(569006); DIR:OUT; SFP:1101; SCL:1; SRVR:HE1PR04MB1529; H:Tophie.ap.freescale.net; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: nxp.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; HE1PR04MB1529; 23:AjvQNIBd+JwwA+wv7xIpGiS/ycQ8gz5MQKM8GJmBj?= CBb06o9jlRTtjdq/bzzuU2fRK/KiX9WxdOz0VCVGlua3PsqphjjhqQ2K3uUhzxgMtC+ZlfHT47MzkZhzA72hct2pijocXvi8ZYpN4s8lfTi5C8zGaAb5GkyUZcl4jpJ+hmuhNciBtp/bFHalCoUCiIuEjwE+/g/kxEHJn1n1uQIgepDXFEyp+y0wQdabGWRDWk/9T5s5h1wtfi2jA0sLRIcuIVB4Sh7h7zzUeqzQ+JPWJFxmGFctbw9FpF92YFYwsZYhHjs9ZhRSVD04zTN7snrZ5J1U2PRn0QBqcWCu3i6BwAI9q5v6wfLXbqCj4JTOWoLorI/qDlsbRxAisrKtbj19H4HMU0WDaL1SSXa6/BP5XvvKa1OBW9V6ZiYcYd0eoaLVAmKFST28sq6mwj7i4ElR05iNVFMqpIzO19TwK0MOKmjGjpjonTlxtpQaQmI6HAm6YwtfhmLTRRNp0qqVZHXCsRiYlQhijZoW8wR8CgUj+ePr/ZqkWFo1/STg9kAitmRDL9+fCZDa2Akbo+dLZYx+lU92pFN6kASXczTWVPbcMbQLlXVZZcT8jH1yhAILoqtMEKA94eBRBmhi3TOYuKW/T9Rm3gBTk68e7MwCvOC/pLDtqixgRn9K92GweSG12v6JtiVpJY2e8bslfYp6mswhBhh3Tz4h6BS0eIJQmTwoedQmnw++DCP8nLox4HNFVCGply1udj7r4gwAK8TFLHsoA8dE1KXH2ZoUXnfSr9nYmk5yClHgu5RgAaCPuZfXQIqHU4GLCBeYDTyD2YUvijAhC636JY3mOAu6MHzTEIyu2mS5iol0v0+0gkxAEexMbO+CRrYP/+MlL0vn5deM8srfKcK9FpcQEV8c81FQ7oI24Eh7KRTYFB2Pxu+DS9RRBi46uY8dcQXUf0hNLrXq9aogmdfxJAkMpKEpDBx0XzOcbYODeVPakhCm2shalEDIAr9vI/l0FpnFQTRUscWkLY2T6eI0g/dabX5mLicQ9rDkXBHRdHy6U8c1rilcReYG1EdR8hq4PlhX7C7Jfz9OvArs99Q7DmmweORoUCbXAUQUXL89o3k66a+ZWRUnNoy1CNLmdnAAjGYXZ4tSqBumPp3t4EiC45BYGzmj+uLNBq/U6R4bGAmPCspW69SGEmOQbIVtr/vQS+YKBffYiuHLROWbZMZJawWZl0E1gQBttZxD+qCVBaNcUsqMMqo5O4mOAVhFy17rQ4CVOyj8SGltIjjWulcwciT4xNxqalFhnr6OCQVAA7qNm3p6xRTpRptlWLo3cMo7QG020T2k0oAfyu9qEjeVWUvJiLKD0yXo9DZU36JiU3BLKT/nlPQzLnIdLiRvi9eSymkBbviHf8Hv/I+Ot0t2KLB0tran1f4+1DfmMbDgbAjwv0Ck+dwN+q0YXE= X-Microsoft-Antispam-Message-Info: xatUdm83d3KlZbdLd6xvkaKlJEa1jVUM4jY96Uc2aYzeRPN+Wo0uJIxQe3cjTe0+MWYip2rx7igQHT2cp1+aImCgMuHg7RdtU7AGdobtnaqKsQiqf2vnYTNwPGM+7J/ffFlc67qARXedyLgp86DJpNSEr87NDcq7kUsRDeLSQMlTYISk5AX9EaJ7WDdAt4VEWuCYih3j2Qwb1jEkjl5zq85YZ+6UIkBlzpvSFQzLZ4DUQR4TVhZDg4j5Woex5fXcym8I+dRPewsCrhEcPfNr061Ah8ktjm1ylUWDlUIRrzZrkKdB6h/1LcdLS30lclrJxsBuB4nnvOOCHBPJWMlxf6RhCqYqpKIo64VMfdl68Mc= X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 6:W4+Uw14p20r7aUCBPt1VWreaaQBCGsMYLKS5p/h90yyKyqrzKdH2hYwYrslBALgUaxyL3YnAXrUPYhv+/M9SIsYNfiJkYmhwNRxxla1Vv+n6v/umFMWy6IWEnoLswpH4c3EjFe5UaoPr5z7lvZ57W+y11sKg/yyq43OrMYXl9Xji58W3dY7Gqkq93eDVg4XaO/31YGr4bs51Yq+XLZ6t4GlGnc3p7X8NFbPv0VghxfCyeCR/g5D0Tc/T4tvLaPVc5GlFgyWRN1hQtOqooUE0KEk/ka+RSJALwjSHgpPbSDoXvTjEnb9AUBNomVRxEB2hyOHSetCfoq83l0dUfmle2RlWXuW/NZSwpVCUBqoH4bPkaS0C4zc4RTyTzAraijKlPPUH3gOw0IjKH3C52BT5Pp0xFMKgTumVU/8BzoXHmPrQu8ZkDtWVrmPyB+9O6lqYI9CxywRB5zpmLjmes9tt3g==; 5:oGNezhhdxeHsCL0obsjXK0V7t5UsFNuZLnH/CScieJjH2ienIKT61BzZxriqK9QkZLH2QVQP0kb2MEfAEzm5vEAXY+wpT5RSzpGcWHtjlrx90PrY+mdbePb8iG0HoMs2gFS4McUpYf7wv7V4shyKwxQAyjWUUrES7jpQ3C7FNqA=; 7:Sj5+3xqwALcxXAFp0EC6zXjAi12QFxaMmAv2zlVVA3AhcL6/QqsDsfJV+X8Susx6A9XLg769EFELfH6cW4IwkBFTSmDaMtvRzZk4imU5C3CW2Jtm/2A4QXhA+4kYE/SCdpiiUyYadWxdjiKTWKEn2mI6vMCahNYKfaXzydAN3zCX5ON9FNJuWkCrJiyKArUdl7RhY95kjGEAxRPLMh/QSJaSXEzxMnVEamELZvwgtxBd5fMx2t5gmpi9gb15i4Ak SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 13 Sep 2018 06:09:26.2883 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 1b4fab3c-6b30-4243-c188-08d6193f761a X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-Transport-CrossTenantHeadersStamped: HE1PR04MB1529 Subject: [dpdk-dev] [PATCH 03/10] crypto/caam_jr: add HW config for job rings 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" From: Hemant Agrawal Signed-off-by: Gagandeep Singh Signed-off-by: Hemant Agrawal --- drivers/crypto/caam_jr/Makefile | 6 + drivers/crypto/caam_jr/caam_jr.c | 329 +++++++++++- drivers/crypto/caam_jr/caam_jr_config.h | 207 ++++++++ drivers/crypto/caam_jr/caam_jr_hw.c | 365 ++++++++++++++ drivers/crypto/caam_jr/caam_jr_hw_specific.h | 503 +++++++++++++++++++ drivers/crypto/caam_jr/caam_jr_pvt.h | 285 +++++++++++ drivers/crypto/caam_jr/caam_jr_uio.c | 491 ++++++++++++++++++ drivers/crypto/caam_jr/meson.build | 5 +- 8 files changed, 2188 insertions(+), 3 deletions(-) create mode 100644 drivers/crypto/caam_jr/caam_jr_config.h create mode 100644 drivers/crypto/caam_jr/caam_jr_hw.c create mode 100644 drivers/crypto/caam_jr/caam_jr_hw_specific.h create mode 100644 drivers/crypto/caam_jr/caam_jr_pvt.h create mode 100644 drivers/crypto/caam_jr/caam_jr_uio.c diff --git a/drivers/crypto/caam_jr/Makefile b/drivers/crypto/caam_jr/Makefile index 46d752af7..8b863b4af 100644 --- a/drivers/crypto/caam_jr/Makefile +++ b/drivers/crypto/caam_jr/Makefile @@ -19,7 +19,10 @@ CFLAGS += -O3 CFLAGS += $(WERROR_FLAGS) endif +CFLAGS += -I$(RTE_SDK)/drivers/bus/dpaa/include CFLAGS += -I$(RTE_SDK)/drivers/crypto/caam_jr +#sharing the hw flib headers from dpaa2_sec pmd +CFLAGS += -I$(RTE_SDK)/drivers/crypto/dpaa2_sec/ CFLAGS += -I$(RTE_SDK)/lib/librte_eal/common/include CFLAGS += -I$(RTE_SDK)/lib/librte_eal/linuxapp/eal @@ -30,11 +33,14 @@ EXPORT_MAP := rte_pmd_caam_jr_version.map LIBABIVER := 1 # library source files +SRCS-$(CONFIG_RTE_LIBRTE_PMD_CAAM_JR) += caam_jr_hw.c +SRCS-$(CONFIG_RTE_LIBRTE_PMD_CAAM_JR) += caam_jr_uio.c SRCS-$(CONFIG_RTE_LIBRTE_PMD_CAAM_JR) += caam_jr.c # library dependencies LDLIBS += -lrte_eal -lrte_mbuf -lrte_mempool -lrte_ring LDLIBS += -lrte_cryptodev +LDLIBS += -lrte_bus_dpaa LDLIBS += -lrte_bus_vdev include $(RTE_SDK)/mk/rte.lib.mk diff --git a/drivers/crypto/caam_jr/caam_jr.c b/drivers/crypto/caam_jr/caam_jr.c index 68779cba5..9d5f5b79b 100644 --- a/drivers/crypto/caam_jr/caam_jr.c +++ b/drivers/crypto/caam_jr/caam_jr.c @@ -16,13 +16,146 @@ #include #include #include +#include +/* RTA header files */ +#include +#include +#include +#include #include #define CRYPTODEV_NAME_CAAM_JR_PMD crypto_caam_jr static uint8_t cryptodev_driver_id; int caam_jr_logtype; +enum rta_sec_era rta_sec_era; + +/* Lists the states possible for the SEC user space driver. */ +enum sec_driver_state_e { + SEC_DRIVER_STATE_IDLE, /* Driver not initialized */ + SEC_DRIVER_STATE_STARTED, /* Driver initialized and can be used*/ + SEC_DRIVER_STATE_RELEASE, /* Driver release is in progress */ +}; + +/* Job rings used for communication with SEC HW */ +static struct sec_job_ring_t g_job_rings[MAX_SEC_JOB_RINGS]; + +/* The current state of SEC user space driver */ +static enum sec_driver_state_e g_driver_state = SEC_DRIVER_STATE_IDLE; + +/* The number of job rings used by SEC user space driver */ +static int g_job_rings_no; +static int g_job_rings_max; + +/* @brief Poll the HW for already processed jobs in the JR + * and silently discard the available jobs or notify them to UA + * with indicated error code. + * + * @param [in,out] job_ring The job ring to poll. + * @param [in] do_notify Can be #TRUE or #FALSE. Indicates if + * descriptors are to be discarded + * or notified to UA with given error_code. + * @param [out] notified_descs Number of notified descriptors. Can be NULL + * if do_notify is #FALSE + */ +static void hw_flush_job_ring(struct sec_job_ring_t *job_ring, + uint32_t do_notify, + uint32_t *notified_descs) +{ + int32_t jobs_no_to_discard = 0; + int32_t discarded_descs_no = 0; + + CAAM_JR_DEBUG("Jr[%p] pi[%d] ci[%d].Flushing jr notify desc=[%d]", + job_ring, job_ring->pidx, job_ring->cidx, do_notify); + + jobs_no_to_discard = hw_get_no_finished_jobs(job_ring); + + /* Discard all jobs */ + CAAM_JR_DEBUG("Jr[%p] pi[%d] ci[%d].Discarding %d descs", + job_ring, job_ring->pidx, job_ring->cidx, + jobs_no_to_discard); + + while (jobs_no_to_discard > discarded_descs_no) { + /* Get completed descriptor */ +#if 0 + /*TODO if we want to do something with desc*/ + /* Since the memory is contigous, then P2V translation is a + * mere addition to the base descriptor physical address + */ + current_desc = job_ring->output_ring[job_ring->cidx].desc; +#endif + + discarded_descs_no++; + /* Now increment the consumer index for the current job ring, + * AFTER saving job in temporary location! + * Increment the consumer index for the current job ring + */ + job_ring->cidx = SEC_CIRCULAR_COUNTER(job_ring->cidx, + SEC_JOB_RING_SIZE); + + hw_remove_entries(job_ring, 1); + } + + if (do_notify == true) { + ASSERT(notified_descs != NULL); + *notified_descs = discarded_descs_no; + } +} + + +/* @brief Flush job rings of any processed descs. + * The processed descs are silently dropped, + * WITHOUT being notified to UA. + */ +static void close_job_ring(struct sec_job_ring_t *job_ring) +{ + if (job_ring->irq_fd) { + /* Producer index is frozen. If consumer index is not equal + * with producer index, then we have descs to flush. + */ + while (job_ring->pidx != job_ring->cidx) + hw_flush_job_ring(job_ring, false, NULL); + + /* free the uio job ring */ + free_job_ring(job_ring->irq_fd); + job_ring->irq_fd = 0; + caam_jr_dma_free(job_ring->input_ring); + caam_jr_dma_free(job_ring->output_ring); + + g_job_rings_no--; + + } +} + +/** @brief Release the software and hardware resources tied to a job ring. + * @param [in] job_ring The job ring + * + * @retval 0 for success + * @retval -1 for error + */ +static int shutdown_job_ring(struct sec_job_ring_t *job_ring) +{ + int ret = 0; + + ASSERT(job_ring != NULL); + ret = hw_shutdown_job_ring(job_ring); + SEC_ASSERT(ret == 0, ret, + "Failed to shutdown hardware job ring %p", + job_ring); + + if (job_ring->coalescing_en) + hw_job_ring_disable_coalescing(job_ring); + + if (job_ring->jr_mode != SEC_NOTIFICATION_TYPE_POLL) { + ret = caam_jr_disable_irqs(job_ring->irq_fd); + SEC_ASSERT(ret == 0, ret, + "Failed to disable irqs for job ring %p", + job_ring); + } + + return ret; +} /* * @brief Release the resources used by the SEC user space driver. @@ -42,31 +175,195 @@ int caam_jr_logtype; static int caam_jr_dev_uninit(struct rte_cryptodev *dev) { + struct sec_job_ring_t *internals; if (dev == NULL) return -ENODEV; + internals = dev->data->dev_private; + rte_free(dev->security_ctx); + + + /* If any descriptors in flight , poll and wait + * until all descriptors are received and silently discarded. + */ + if (internals) { + shutdown_job_ring(internals); + close_job_ring(internals); + rte_mempool_free(internals->ctx_pool); + } CAAM_JR_INFO("Closing DPAA_SEC device %s", dev->data->name); + /* last caam jr instance) */ + if (g_job_rings_no == 0) + g_driver_state = SEC_DRIVER_STATE_IDLE; - return 0; + return SEC_SUCCESS; } +/* @brief Initialize the software and hardware resources tied to a job ring. + * @param [in] jr_mode; Model to be used by SEC Driver to receive + * notifications from SEC. Can be either + * of the three: #SEC_NOTIFICATION_TYPE_NAPI + * #SEC_NOTIFICATION_TYPE_IRQ or + * #SEC_NOTIFICATION_TYPE_POLL + * @param [in] NAPI_mode The NAPI work mode to configure a job ring at + * startup. Used only when #SEC_NOTIFICATION_TYPE + * is set to #SEC_NOTIFICATION_TYPE_NAPI. + * @param [in] irq_coalescing_timer This value determines the maximum + * amount of time after processing a + * descriptor before raising an interrupt. + * @param [in] irq_coalescing_count This value determines how many + * descriptors are completed before + * raising an interrupt. + * @param [in] reg_base_addr, The job ring base address register + * @param [in] irq_id The job ring interrupt identification number. + * @retval job_ring_handle for successful job ring configuration + * @retval NULL on error + * + */ +static void * +init_job_ring(void *reg_base_addr, uint32_t irq_id) +{ + struct sec_job_ring_t *job_ring = NULL; + int i, ret = 0; + int jr_mode = SEC_NOTIFICATION_TYPE_POLL; + int napi_mode = 0; + int irq_coalescing_timer = 0; + int irq_coalescing_count = 0; + + for (i = 0; i < MAX_SEC_JOB_RINGS; i++) { + if (g_job_rings[i].irq_fd == 0) { + job_ring = &g_job_rings[i]; + g_job_rings_no++; + break; + } + } + if (job_ring == NULL) { + CAAM_JR_ERR("No free job ring\n"); + return NULL; + } + + job_ring->register_base_addr = reg_base_addr; + job_ring->jr_mode = jr_mode; + job_ring->napi_mode = 0; + job_ring->irq_fd = irq_id; + + /* Allocate mem for input and output ring */ + + /* Allocate memory for input ring */ + job_ring->input_ring = caam_jr_dma_mem_alloc(L1_CACHE_BYTES, + SEC_DMA_MEM_INPUT_RING_SIZE); + memset(job_ring->input_ring, 0, SEC_DMA_MEM_INPUT_RING_SIZE); + + /* Allocate memory for output ring */ + job_ring->output_ring = caam_jr_dma_mem_alloc(L1_CACHE_BYTES, + SEC_DMA_MEM_OUTPUT_RING_SIZE); + memset(job_ring->output_ring, 0, SEC_DMA_MEM_OUTPUT_RING_SIZE); + + /* Reset job ring in SEC hw and configure job ring registers */ + ret = hw_reset_job_ring(job_ring); + if (ret != 0) { + CAAM_JR_ERR("Failed to reset hardware job ring"); + goto cleanup; + } + + if (jr_mode == SEC_NOTIFICATION_TYPE_NAPI) { + /* When SEC US driver works in NAPI mode, the UA can select + * if the driver starts with IRQs on or off. + */ + if (napi_mode == SEC_STARTUP_INTERRUPT_MODE) { + CAAM_JR_INFO("Enabling DONE IRQ generationon job ring - %p", + job_ring); + ret = caam_jr_enable_irqs(job_ring->irq_fd); + if (ret != 0) { + CAAM_JR_ERR("Failed to enable irqs for job ring"); + goto cleanup; + } + } + } else if (jr_mode == SEC_NOTIFICATION_TYPE_IRQ) { + /* When SEC US driver works in pure interrupt mode, + * IRQ's are always enabled. + */ + CAAM_JR_INFO("Enabling DONE IRQ generation on job ring - %p", + job_ring); + ret = caam_jr_enable_irqs(job_ring->irq_fd); + if (ret != 0) { + CAAM_JR_ERR("Failed to enable irqs for job ring"); + goto cleanup; + } + } + if (irq_coalescing_timer || irq_coalescing_count) { + hw_job_ring_set_coalescing_param(job_ring, + irq_coalescing_timer, + irq_coalescing_count); + + hw_job_ring_enable_coalescing(job_ring); + job_ring->coalescing_en = 1; + } + + job_ring->jr_state = SEC_JOB_RING_STATE_STARTED; + job_ring->max_nb_queue_pairs = RTE_CAAM_MAX_NB_SEC_QPS; + job_ring->max_nb_sessions = RTE_CAAM_JR_PMD_MAX_NB_SESSIONS; + + return job_ring; +cleanup: + caam_jr_dma_free(job_ring->output_ring); + caam_jr_dma_free(job_ring->input_ring); + return NULL; +} + + static int caam_jr_dev_init(const char *name, struct rte_vdev_device *vdev, struct rte_cryptodev_pmd_init_params *init_params) { struct rte_cryptodev *dev; + struct uio_job_ring *job_ring; + char str[RTE_CRYPTODEV_NAME_MAX_LEN]; PMD_INIT_FUNC_TRACE(); + /* Validate driver state */ + if (g_driver_state == SEC_DRIVER_STATE_IDLE) { + g_job_rings_max = sec_configure(); + if (!g_job_rings_max) { + CAAM_JR_ERR("No job ring detected on UIO !!!!"); + return -1; + } + /* Update driver state */ + g_driver_state = SEC_DRIVER_STATE_STARTED; + } + + if (g_job_rings_no >= g_job_rings_max) { + CAAM_JR_ERR("No more job rings available max=%d!!!!", + g_job_rings_max); + return -1; + } + + job_ring = config_job_ring(); + if (job_ring == NULL) { + CAAM_JR_ERR("failed to create job ring"); + goto init_error; + } + + snprintf(str, sizeof(str), "caam_jr%d", job_ring->jr_id); + dev = rte_cryptodev_pmd_create(name, &vdev->device, init_params); if (dev == NULL) { CAAM_JR_ERR("failed to create cryptodev vdev"); goto cleanup; } + /*TODO free it during teardown*/ + dev->data->dev_private = init_job_ring(job_ring->register_base_addr, + job_ring->uio_fd); + + if (!dev->data->dev_private) { + CAAM_JR_ERR("Ring memory allocation failed\n"); + goto cleanup2; + } dev->driver_id = cryptodev_driver_id; dev->dev_ops = NULL; @@ -84,7 +381,12 @@ caam_jr_dev_init(const char *name, return 0; +cleanup2: + caam_jr_dev_uninit(dev); + rte_cryptodev_pmd_release_device(dev); cleanup: + free_job_ring(job_ring->uio_fd); +init_error: CAAM_JR_ERR("driver %s: cryptodev_caam_jr_create failed", init_params->name); @@ -97,7 +399,7 @@ cryptodev_caam_jr_probe(struct rte_vdev_device *vdev) { struct rte_cryptodev_pmd_init_params init_params = { "", - 128, + sizeof(struct sec_job_ring_t), rte_socket_id(), RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_QUEUE_PAIRS }; @@ -111,6 +413,29 @@ cryptodev_caam_jr_probe(struct rte_vdev_device *vdev) input_args = rte_vdev_device_args(vdev); rte_cryptodev_pmd_parse_input_args(&init_params, input_args); + /* if sec device version is not configured */ + if (!rta_get_sec_era()) { + const struct device_node *caam_node; + + for_each_compatible_node(caam_node, NULL, "fsl,sec-v4.0") { + const uint32_t *prop = of_get_property(caam_node, + "fsl,sec-era", + NULL); + if (prop) { + rta_set_sec_era( + INTL_SEC_ERA(cpu_to_caam32(*prop))); + break; + } + } + } +#ifdef RTE_LIBRTE_PMD_CAAM_JR_BE + if (rta_get_sec_era() > RTA_SEC_ERA_8) { + RTE_LOG(ERR, PMD, + "CAAM is compiled in BE mode for device with sec era > 8???\n"); + return -EINVAL; + } +#endif + return caam_jr_dev_init(name, vdev, &init_params); } diff --git a/drivers/crypto/caam_jr/caam_jr_config.h b/drivers/crypto/caam_jr/caam_jr_config.h new file mode 100644 index 000000000..e7855cee6 --- /dev/null +++ b/drivers/crypto/caam_jr/caam_jr_config.h @@ -0,0 +1,207 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright 2017-2018 NXP + */ + +#ifndef CAAM_JR_CONFIG_H +#define CAAM_JR_CONFIG_H + +#include + +#ifdef RTE_LIBRTE_PMD_CAAM_JR_BE +#define CAAM_BYTE_ORDER __BIG_ENDIAN +#else +#define CAAM_BYTE_ORDER __LITTLE_ENDIAN +#endif + +#if RTE_BYTE_ORDER == RTE_BIG_ENDIAN +#define CORE_BYTE_ORDER __BIG_ENDIAN +#else +#define CORE_BYTE_ORDER __LITTLE_ENDIAN +#endif + +typedef uint64_t dma_addr_t; + +#if CORE_BYTE_ORDER != CAAM_BYTE_ORDER + +#define cpu_to_caam64 rte_cpu_to_be_64 +#define cpu_to_caam32 rte_cpu_to_be_32 +#else +#define cpu_to_caam64 +#define cpu_to_caam32 + +#endif + +/* + * SEC is configured to start work in polling mode, + * when configured for NAPI notification style. + */ +#define SEC_STARTUP_POLLING_MODE 0 +/* + * SEC is configured to start work in interrupt mode, + * when configured for NAPI notification style. + */ +#define SEC_STARTUP_INTERRUPT_MODE 1 + +/* + * SEC driver will use NAPI model to receive notifications + * for processed packets from SEC engine hardware: + * - IRQ for low traffic + * - polling for high traffic. + */ +#define SEC_NOTIFICATION_TYPE_NAPI 0 +/* + * SEC driver will use ONLY interrupts to receive notifications + * for processed packets from SEC engine hardware. + */ +#define SEC_NOTIFICATION_TYPE_IRQ 1 +/* + * SEC driver will use ONLY polling to receive notifications + * for processed packets from SEC engine hardware. + */ +#define SEC_NOTIFICATION_TYPE_POLL 2 + +/* + * SEC USER SPACE DRIVER related configuration. + */ + +/* + * Determines how SEC user space driver will receive notifications + * for processed packets from SEC engine. + * Valid values are: #SEC_NOTIFICATION_TYPE_POLL, #SEC_NOTIFICATION_TYPE_IRQ + * and #SEC_NOTIFICATION_TYPE_NAPI. + */ +#define SEC_NOTIFICATION_TYPE SEC_NOTIFICATION_TYPE_POLL + +/* Maximum number of job rings supported by SEC hardware */ +#define MAX_SEC_JOB_RINGS 4 + +/* Maximum number of QP per job ring */ +#define RTE_CAAM_MAX_NB_SEC_QPS 1 + +/* + * Size of cryptographic context that is used directly in communicating + * with SEC device. SEC device works only with physical addresses. This + * is the maximum size for a SEC descriptor ( = 64 words). + */ +#define SEC_CRYPTO_DESCRIPTOR_SIZE 256 + +/* + * Size of job descriptor submitted to SEC device for each packet to + * be processed. + * Job descriptor contains 3 DMA address pointers: + * - to shared descriptor, to input buffer and to output buffer. + * The job descriptor contains other SEC specific commands as well: + * - HEADER command, SEQ IN PTR command SEQ OUT PTR command and opaque data + * each measuring 4 bytes. + * Job descriptor size, depending on physical address representation: + * - 32 bit - size is 28 bytes - cacheline-aligned size is 64 bytes + * - 36 bit - size is 40 bytes - cacheline-aligned size is 64 bytes + * @note: Job descriptor must be cacheline-aligned to ensure efficient + * memory access. + * @note: If other format is used for job descriptor, then the size must be + * revised. + */ +#define SEC_JOB_DESCRIPTOR_SIZE 64 + +/* + * Size of one entry in the input ring of a job ring. + * Input ring contains pointers to job descriptors. + * The memory used for an input ring and output ring must be physically + * contiguous. + */ +#define SEC_JOB_INPUT_RING_ENTRY_SIZE sizeof(dma_addr_t) + +/* + * Size of one entry in the output ring of a job ring. + * Output ring entry is a pointer to a job descriptor followed by a 4 byte + * status word. + * The memory used for an input ring and output ring must be physically + * contiguous. + * @note If desired to use also the optional SEQ OUT indication in output ring + * entries, + * then 4 more bytes must be added to the size. + */ +#define SEC_JOB_OUTPUT_RING_ENTRY_SIZE (SEC_JOB_INPUT_RING_ENTRY_SIZE + 4) + +/* + * DMA memory required for an input ring of a job ring. + */ +#define SEC_DMA_MEM_INPUT_RING_SIZE ((SEC_JOB_INPUT_RING_ENTRY_SIZE) * \ + (SEC_JOB_RING_SIZE)) + +/* + * DMA memory required for an output ring of a job ring. + * Required extra 4 byte for status word per each entry. + */ +#define SEC_DMA_MEM_OUTPUT_RING_SIZE ((SEC_JOB_OUTPUT_RING_ENTRY_SIZE) * \ + (SEC_JOB_RING_SIZE)) + +/* DMA memory required for a job ring, including both input and output rings. */ +#define SEC_DMA_MEM_JOB_RING_SIZE ((SEC_DMA_MEM_INPUT_RING_SIZE) + \ + (SEC_DMA_MEM_OUTPUT_RING_SIZE)) + +/* + * When calling sec_init() UA will provide an area of virtual memory + * of size #SEC_DMA_MEMORY_SIZE to be used internally by the driver + * to allocate data (like SEC descriptors) that needs to be passed to + * SEC device in physical addressing and later on retrieved from SEC device. + * At initialization the UA provides specialized ptov/vtop functions/macros to + * translate addresses allocated from this memory area. + */ +#define SEC_DMA_MEMORY_SIZE ((SEC_DMA_MEM_JOB_RING_SIZE) * \ + (MAX_SEC_JOB_RINGS)) + +#define L1_CACHE_BYTES 64 + +/* SEC JOB RING related configuration. */ + +/* + * Configure the size of the JOB RING. + * The maximum size of the ring in hardware limited to 1024. + * However the number of packets in flight in a time interval of 1ms can + * be calculated from the traffic rate (Mbps) and packet size. + * Here it was considered a packet size of 64 bytes. + * + * @note Round up to nearest power of 2 for optimized update + * of producer/consumer indexes of each job ring + */ +#define SEC_JOB_RING_SIZE 512 + +/* + * Interrupt coalescing related configuration. + * NOTE: SEC hardware enabled interrupt + * coalescing is not supported on SEC version 3.1! + * SEC version 4.4 has support for interrupt + * coalescing. + */ + +#if SEC_NOTIFICATION_TYPE != SEC_NOTIFICATION_TYPE_POLL + +#define SEC_INT_COALESCING_ENABLE 1 +/* + * Interrupt Coalescing Descriptor Count Threshold. + * While interrupt coalescing is enabled (ICEN=1), this value determines + * how many Descriptors are completed before raising an interrupt. + * + * Valid values for this field are from 0 to 255. + * Note that a value of 1 functionally defeats the advantages of interrupt + * coalescing since the threshold value is reached each time that a + * Job Descriptor is completed. A value of 0 is treated in the same + * manner as a value of 1. + */ +#define SEC_INTERRUPT_COALESCING_DESCRIPTOR_COUNT_THRESH 10 + +/* + * Interrupt Coalescing Timer Threshold. + * While interrupt coalescing is enabled (ICEN=1), this value determines the + * maximum amount of time after processing a Descriptor before raising an + * interrupt. + * The threshold value is represented in units equal to 64 CAAM interface + * clocks. Valid values for this field are from 1 to 65535. + * A value of 0 results in behavior identical to that when interrupt + * coalescing is disabled. + */ +#define SEC_INTERRUPT_COALESCING_TIMER_THRESH 100 +#endif /* SEC_NOTIFICATION_TYPE_POLL */ + +#endif /* CAAM_JR_CONFIG_H */ diff --git a/drivers/crypto/caam_jr/caam_jr_hw.c b/drivers/crypto/caam_jr/caam_jr_hw.c new file mode 100644 index 000000000..5baac95f8 --- /dev/null +++ b/drivers/crypto/caam_jr/caam_jr_hw.c @@ -0,0 +1,365 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright 2017-2018 NXP + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* RTA header files */ +#include +#include +#include + +#include +#include +#include + +/* Used to retry resetting a job ring in SEC hardware. */ +#define SEC_TIMEOUT 100000 + +/* @brief Process Jump Halt Condition related errors + * + * @param [in] error_code The error code in the descriptor status word + */ +static inline void hw_handle_jmp_halt_cond_err(union hw_error_code + error_code) { + CAAM_JR_DEBUG("JMP: %d, Descriptor Index: 0x%x, Condition: 0x%x", + error_code.error_desc.jmp_halt_cond_src.jmp, + error_code.error_desc.jmp_halt_cond_src.desc_idx, + error_code.error_desc.jmp_halt_cond_src.cond); + (void)error_code; +} + +/* @brief Process DECO related errors + * + * @param [in] error_code The error code in the descriptor status word + */ +static inline void hw_handle_deco_err(union hw_error_code + error_code) { + CAAM_JR_DEBUG("JMP: %d, Descriptor Index: 0x%x", + error_code.error_desc.deco_src.jmp, + error_code.error_desc.deco_src.desc_idx); + + switch (error_code.error_desc.deco_src.desc_err) { + case SEC_HW_ERR_DECO_HFN_THRESHOLD: + CAAM_JR_DEBUG(" Warning: Descriptor completed normally," + "but 3GPP HFN matches or exceeds the Threshold "); + break; + default: + CAAM_JR_DEBUG("Error 0x%04x not implemented", + error_code.error_desc.deco_src.desc_err); + break; + } +} + +/* @brief Process Jump Halt User Status related errors + * + * @param [in] error_code The error code in the descriptor status word + */ +static inline void hw_handle_jmp_halt_user_err(union hw_error_code + error_code __rte_unused) +{ + CAAM_JR_DEBUG(" Not implemented"); +} + +/* @brief Process CCB related errors + * + * @param [in] error_code The error code in the descriptor status word + */ +static inline void +hw_handle_ccb_err(union hw_error_code hw_error_code __rte_unused) +{ + CAAM_JR_DEBUG(" Not implemented"); +} + +/* @brief Process Job Ring related errors + * + * @param [in] error_code The error code in the descriptor status word + */ +static inline +void hw_handle_jr_err(union hw_error_code hw_error_code __rte_unused) +{ + CAAM_JR_DEBUG(" Not implemented"); +} + +int hw_reset_job_ring(struct sec_job_ring_t *job_ring) +{ + int ret = 0; + + ASSERT(job_ring->register_base_addr != NULL); + + /* First reset the job ring in hw */ + ret = hw_shutdown_job_ring(job_ring); + SEC_ASSERT(ret == 0, ret, "Failed resetting job ring in hardware"); + + /* In order to have the HW JR in a workable state + * after a reset, I need to re-write the input + * queue size, input start address, output queue + * size and output start address + */ + /* Write the JR input queue size to the HW register */ + hw_set_input_ring_size(job_ring, SEC_JOB_RING_SIZE); + + /* Write the JR output queue size to the HW register */ + hw_set_output_ring_size(job_ring, SEC_JOB_RING_SIZE); + + /* Write the JR input queue start address */ + hw_set_input_ring_start_addr(job_ring, + caam_jr_dma_vtop(job_ring->input_ring)); + CAAM_JR_DEBUG(" Set input ring base address to : Virtual: 0x%" PRIx64 + ",Physical: 0x%" PRIx64 ", Read from HW: 0x%" PRIx64, + (uint64_t)(uintptr_t)job_ring->input_ring, + caam_jr_dma_vtop(job_ring->input_ring), + hw_get_inp_queue_base(job_ring)); + + /* Write the JR output queue start address */ + hw_set_output_ring_start_addr(job_ring, + caam_jr_dma_vtop(job_ring->output_ring)); + CAAM_JR_DEBUG(" Set output ring base address to: Virtual: 0x%" PRIx64 + ",Physical: 0x%" PRIx64 ", Read from HW: 0x%" PRIx64, + (uint64_t)(uintptr_t)job_ring->output_ring, + caam_jr_dma_vtop(job_ring->output_ring), + hw_get_out_queue_base(job_ring)); + return ret; +} + +int hw_shutdown_job_ring(struct sec_job_ring_t *job_ring) +{ + unsigned int timeout = SEC_TIMEOUT; + uint32_t tmp = 0; + int usleep_interval = 10; + + if (job_ring->register_base_addr == NULL) { + CAAM_JR_ERR("Jr[%p] has reg base addr as NULL.driver not init", + job_ring); + return 0; + } + + CAAM_JR_INFO("Resetting Job ring %p", job_ring); + + /* + * Mask interrupts since we are going to poll + * for reset completion status + * Also, at POR, interrupts are ENABLED on a JR, thus + * this is the point where I can disable them without + * changing the code logic too much + */ + caam_jr_disable_irqs(job_ring->irq_fd); + + /* initiate flush (required prior to reset) */ + SET_JR_REG(JRCR, job_ring, JR_REG_JRCR_VAL_RESET); + + /* dummy read */ + tmp = GET_JR_REG(JRCR, job_ring); + + do { + tmp = GET_JR_REG(JRINT, job_ring); + usleep(usleep_interval); + } while (((tmp & JRINT_ERR_HALT_MASK) == + JRINT_ERR_HALT_INPROGRESS) && --timeout); + + CAAM_JR_INFO("JRINT is %x", tmp); + + if ((tmp & JRINT_ERR_HALT_MASK) != JRINT_ERR_HALT_COMPLETE || + timeout == 0) { + CAAM_JR_ERR("0x%x, %d", tmp, timeout); + /* unmask interrupts */ + if (job_ring->jr_mode != SEC_NOTIFICATION_TYPE_POLL) + caam_jr_enable_irqs(job_ring->irq_fd); + return -1; + } + + /* Initiate reset */ + timeout = SEC_TIMEOUT; + SET_JR_REG(JRCR, job_ring, JR_REG_JRCR_VAL_RESET); + + do { + tmp = GET_JR_REG(JRCR, job_ring); + usleep(usleep_interval); + } while ((tmp & JR_REG_JRCR_VAL_RESET) && --timeout); + + CAAM_JR_DEBUG("JRCR is %x", tmp); + + if (timeout == 0) { + CAAM_JR_ERR("Failed to reset hw job ring %p", job_ring); + /* unmask interrupts */ + if (job_ring->jr_mode != SEC_NOTIFICATION_TYPE_POLL) + caam_jr_enable_irqs(job_ring->irq_fd); + return -1; + } + /* unmask interrupts */ + if (job_ring->jr_mode != SEC_NOTIFICATION_TYPE_POLL) + caam_jr_enable_irqs(job_ring->irq_fd); + return 0; + +} + +void hw_handle_job_ring_error(struct sec_job_ring_t *job_ring __rte_unused, + uint32_t error_code) +{ + union hw_error_code hw_err_code; + + hw_err_code.error = error_code; + + switch (hw_err_code.error_desc.value.ssrc) { + case SEC_HW_ERR_SSRC_NO_SRC: + ASSERT(hw_err_code.error_desc.no_status_src.res == 0); + CAAM_JR_ERR("No Status Source "); + break; + case SEC_HW_ERR_SSRC_CCB_ERR: + CAAM_JR_ERR("CCB Status Source"); + hw_handle_ccb_err(hw_err_code); + break; + case SEC_HW_ERR_SSRC_JMP_HALT_U: + CAAM_JR_ERR("Jump Halt User Status Source"); + hw_handle_jmp_halt_user_err(hw_err_code); + break; + case SEC_HW_ERR_SSRC_DECO: + CAAM_JR_ERR("DECO Status Source"); + hw_handle_deco_err(hw_err_code); + break; + case SEC_HW_ERR_SSRC_JR: + CAAM_JR_ERR("Job Ring Status Source"); + hw_handle_jr_err(hw_err_code); + break; + case SEC_HW_ERR_SSRC_JMP_HALT_COND: + CAAM_JR_ERR("Jump Halt Condition Codes"); + hw_handle_jmp_halt_cond_err(hw_err_code); + break; + default: + ASSERT(0); + CAAM_JR_ERR("Unknown SSRC"); + break; + } +} + +void hw_job_ring_error_print(struct sec_job_ring_t *job_ring, int code) +{ + switch (code) { + case JRINT_ERR_WRITE_STATUS: + CAAM_JR_ERR("Error writing status to Output Ring "); + break; + case JRINT_ERR_BAD_INPUT_BASE: + CAAM_JR_ERR( + "Bad Input Ring Base (%p) (not on a 4-byte boundary) ", + (void *)job_ring); + break; + case JRINT_ERR_BAD_OUTPUT_BASE: + CAAM_JR_ERR( + "Bad Output Ring Base (%p) (not on a 4-byte boundary) ", + (void *)job_ring); + break; + case JRINT_ERR_WRITE_2_IRBA: + CAAM_JR_ERR( + "Invalid write to Input Ring Base Address Register "); + break; + case JRINT_ERR_WRITE_2_ORBA: + CAAM_JR_ERR( + "Invalid write to Output Ring Base Address Register "); + break; + case JRINT_ERR_RES_B4_HALT: + CAAM_JR_ERR( + "Job Ring [%p] released before Job Ring is halted", + (void *)job_ring); + break; + case JRINT_ERR_REM_TOO_MANY: + CAAM_JR_ERR("Removed too many jobs from job ring [%p]", + (void *)job_ring); + break; + case JRINT_ERR_ADD_TOO_MANY: + CAAM_JR_ERR("Added too many jobs on job ring [%p]", job_ring); + break; + default: + CAAM_JR_ERR(" Unknown SEC JR Error :%d", + code); + break; + } +} + +int hw_job_ring_set_coalescing_param(struct sec_job_ring_t *job_ring, + uint16_t irq_coalescing_timer, + uint8_t irq_coalescing_count) +{ + uint32_t reg_val = 0; + + ASSERT(job_ring != NULL); + + if (job_ring->register_base_addr == NULL) { + CAAM_JR_ERR("Jr[%p] has reg base addr as NULL.driver not init", + job_ring); + return -1; + } + /* Set descriptor count coalescing */ + reg_val |= (irq_coalescing_count << JR_REG_JRCFG_LO_ICDCT_SHIFT); + + /* Set coalescing timer value */ + reg_val |= (irq_coalescing_timer << JR_REG_JRCFG_LO_ICTT_SHIFT); + + /* Update parameters in HW */ + SET_JR_REG_LO(JRCFG, job_ring, reg_val); + + CAAM_JR_DEBUG("Set coalescing params on jr %p timer:%d, desc count: %d", + job_ring, irq_coalescing_timer, irq_coalescing_timer); + + return 0; +} + +int hw_job_ring_enable_coalescing(struct sec_job_ring_t *job_ring) +{ + uint32_t reg_val = 0; + + ASSERT(job_ring != NULL); + if (job_ring->register_base_addr == NULL) { + CAAM_JR_ERR("Jr[%p] has reg base addr as NULL.driver not init", + job_ring); + return -1; + } + + /* Get the current value of the register */ + reg_val = GET_JR_REG_LO(JRCFG, job_ring); + + /* Enable coalescing */ + reg_val |= JR_REG_JRCFG_LO_ICEN_EN; + + /* Write in hw */ + SET_JR_REG_LO(JRCFG, job_ring, reg_val); + + CAAM_JR_DEBUG("Enabled coalescing on jr %p ", + job_ring); + + return 0; +} + +int hw_job_ring_disable_coalescing(struct sec_job_ring_t *job_ring) +{ + uint32_t reg_val = 0; + + ASSERT(job_ring != NULL); + + if (job_ring->register_base_addr == NULL) { + CAAM_JR_ERR("Jr[%p] has reg base addr as NULL.driver not init", + job_ring); + return -1; + } + + /* Get the current value of the register */ + reg_val = GET_JR_REG_LO(JRCFG, job_ring); + + /* Disable coalescing */ + reg_val &= ~JR_REG_JRCFG_LO_ICEN_EN; + + /* Write in hw */ + SET_JR_REG_LO(JRCFG, job_ring, reg_val); + + CAAM_JR_DEBUG("Disabled coalescing on jr %p ", job_ring); + + return 0; + +} diff --git a/drivers/crypto/caam_jr/caam_jr_hw_specific.h b/drivers/crypto/caam_jr/caam_jr_hw_specific.h new file mode 100644 index 000000000..7c8909d2b --- /dev/null +++ b/drivers/crypto/caam_jr/caam_jr_hw_specific.h @@ -0,0 +1,503 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright 2017 NXP + */ + +#ifndef CAAM_JR_HW_SPECIFIC_H +#define CAAM_JR_HW_SPECIFIC_H + +#include + +/* + * Offset to the registers of a job ring. + * Is different for each job ring. + */ +#define CHAN_BASE(jr) ((size_t)(jr)->register_base_addr) + +#ifndef unlikely +#define unlikely(x) __builtin_expect(!!(x), 0) +#endif + +#define SEC_JOB_RING_IS_FULL(pi, ci, ring_max_size, ring_threshold) \ + ((((pi) + 1 + ((ring_max_size) - (ring_threshold))) & \ + (ring_max_size - 1)) == ((ci))) + +#define SEC_CIRCULAR_COUNTER(x, max) (((x) + 1) & (max - 1)) + +/* + * Assert that cond is true. If !cond is true, display str and the vararg list + * in a printf-like syntax. also, if !cond is true, return altRet. + * + * \param cond A boolean expression to be asserted true + * \param altRet The value to be returned if cond doesn't hold true + * \param str A quoted char string + * + * E.g.: + * SEC_ASSERT(ret > 0, 0, "ERROR initializing app: code = %d\n", ret); + */ +#define SEC_ASSERT(cond, altRet, ...) {\ + if (unlikely(!(cond))) {\ + CAAM_JR_ERR(__VA_ARGS__); \ + return altRet; \ + } \ +} + +#define SEC_DP_ASSERT(cond, altRet, ...) {\ + if (unlikely(!(cond))) {\ + CAAM_JR_DP_ERR(__VA_ARGS__); \ + return altRet; \ + } \ +} + +#define ASSERT(x) + +/* + * Constants representing various job ring registers + */ +#if CAAM_BYTE_ORDER == __BIG_ENDIAN +#define JR_REG_IRBA_OFFSET 0x0000 +#define JR_REG_IRBA_OFFSET_LO 0x0004 +#else +#define JR_REG_IRBA_OFFSET 0x0004 +#define JR_REG_IRBA_OFFSET_LO 0x0000 +#endif + +#define JR_REG_IRSR_OFFSET 0x000C +#define JR_REG_IRSA_OFFSET 0x0014 +#define JR_REG_IRJA_OFFSET 0x001C + +#if CAAM_BYTE_ORDER == __BIG_ENDIAN +#define JR_REG_ORBA_OFFSET 0x0020 +#define JR_REG_ORBA_OFFSET_LO 0x0024 +#else +#define JR_REG_ORBA_OFFSET 0x0024 +#define JR_REG_ORBA_OFFSET_LO 0x0020 +#endif + +#define JR_REG_ORSR_OFFSET 0x002C +#define JR_REG_ORJR_OFFSET 0x0034 +#define JR_REG_ORSFR_OFFSET 0x003C +#define JR_REG_JROSR_OFFSET 0x0044 +#define JR_REG_JRINT_OFFSET 0x004C + +#define JR_REG_JRCFG_OFFSET 0x0050 +#define JR_REG_JRCFG_OFFSET_LO 0x0054 + +#define JR_REG_IRRI_OFFSET 0x005C +#define JR_REG_ORWI_OFFSET 0x0064 +#define JR_REG_JRCR_OFFSET 0x006C + +/* + * Constants for error handling on job ring + */ +#define JR_REG_JRINT_ERR_TYPE_SHIFT 8 +#define JR_REG_JRINT_ERR_ORWI_SHIFT 16 +#define JR_REG_JRINIT_JRE_SHIFT 1 + +#define JRINT_JRE (1 << JR_REG_JRINIT_JRE_SHIFT) +#define JRINT_ERR_WRITE_STATUS (1 << JR_REG_JRINT_ERR_TYPE_SHIFT) +#define JRINT_ERR_BAD_INPUT_BASE (3 << JR_REG_JRINT_ERR_TYPE_SHIFT) +#define JRINT_ERR_BAD_OUTPUT_BASE (4 << JR_REG_JRINT_ERR_TYPE_SHIFT) +#define JRINT_ERR_WRITE_2_IRBA (5 << JR_REG_JRINT_ERR_TYPE_SHIFT) +#define JRINT_ERR_WRITE_2_ORBA (6 << JR_REG_JRINT_ERR_TYPE_SHIFT) +#define JRINT_ERR_RES_B4_HALT (7 << JR_REG_JRINT_ERR_TYPE_SHIFT) +#define JRINT_ERR_REM_TOO_MANY (8 << JR_REG_JRINT_ERR_TYPE_SHIFT) +#define JRINT_ERR_ADD_TOO_MANY (9 << JR_REG_JRINT_ERR_TYPE_SHIFT) +#define JRINT_ERR_HALT_MASK 0x0C +#define JRINT_ERR_HALT_INPROGRESS 0x04 +#define JRINT_ERR_HALT_COMPLETE 0x08 + +#define JR_REG_JRCR_VAL_RESET 0x00000001 + +#define JR_REG_JRCFG_LO_ICTT_SHIFT 0x10 +#define JR_REG_JRCFG_LO_ICDCT_SHIFT 0x08 +#define JR_REG_JRCFG_LO_ICEN_EN 0x02 + +/* + * Constants for Descriptor Processing errors + */ +#define SEC_HW_ERR_SSRC_NO_SRC 0x00 +#define SEC_HW_ERR_SSRC_CCB_ERR 0x02 +#define SEC_HW_ERR_SSRC_JMP_HALT_U 0x03 +#define SEC_HW_ERR_SSRC_DECO 0x04 +#define SEC_HW_ERR_SSRC_JR 0x06 +#define SEC_HW_ERR_SSRC_JMP_HALT_COND 0x07 + +#define SEC_HW_ERR_DECO_HFN_THRESHOLD 0xF1 +#define SEC_HW_ERR_CCB_ICV_CHECK_FAIL 0x0A + +/* + * Constants for descriptors + */ +/* Return higher 32 bits of physical address */ +#define PHYS_ADDR_HI(phys_addr) \ + (uint32_t)(((uint64_t)phys_addr) >> 32) + +/* Return lower 32 bits of physical address */ +#define PHYS_ADDR_LO(phys_addr) \ + (uint32_t)(((uint64_t)phys_addr) & 0xFFFFFFFF) + +/* + * Macros for extracting error codes for the job ring + */ +#define JR_REG_JRINT_ERR_TYPE_EXTRACT(value) ((value) & 0x00000F00) +#define JR_REG_JRINT_ERR_ORWI_EXTRACT(value) \ + (((value) & 0x3FFF0000) >> JR_REG_JRINT_ERR_ORWI_SHIFT) +#define JR_REG_JRINT_JRE_EXTRACT(value) ((value) & JRINT_JRE) + +/* + * Macros for managing the job ring + */ +/* Read pointer to job ring input ring start address */ +#if defined(RTE_ARCH_ARM64) +#define hw_get_inp_queue_base(jr) ((((dma_addr_t)GET_JR_REG(IRBA, (jr))) << 32) | \ + (GET_JR_REG_LO(IRBA, (jr)))) + +/* Read pointer to job ring output ring start address */ +#define hw_get_out_queue_base(jr) (((dma_addr_t)(GET_JR_REG(ORBA, (jr))) << 32) | \ + (GET_JR_REG_LO(ORBA, (jr)))) +#else +#define hw_get_inp_queue_base(jr) ((dma_addr_t)(GET_JR_REG_LO(IRBA, (jr)))) + +#define hw_get_out_queue_base(jr) ((dma_addr_t)(GET_JR_REG_LO(ORBA, (jr)))) +#endif + +/* + * IRJA - Input Ring Jobs Added Register shows + * how many new jobs were added to the Input Ring. + */ +#define hw_enqueue_desc_on_job_ring(job_ring) SET_JR_REG(IRJA, (job_ring), 1) + +#define hw_set_input_ring_size(job_ring, size) SET_JR_REG(IRSR, job_ring, (size)) + +#define hw_set_output_ring_size(job_ring, size) SET_JR_REG(ORSR, job_ring, (size)) + +#if defined(RTE_ARCH_ARM64) +#define hw_set_input_ring_start_addr(job_ring, start_addr) \ +{ \ + SET_JR_REG(IRBA, job_ring, PHYS_ADDR_HI(start_addr)); \ + SET_JR_REG_LO(IRBA, job_ring, PHYS_ADDR_LO(start_addr));\ +} + +#define hw_set_output_ring_start_addr(job_ring, start_addr) \ +{ \ + SET_JR_REG(ORBA, job_ring, PHYS_ADDR_HI(start_addr)); \ + SET_JR_REG_LO(ORBA, job_ring, PHYS_ADDR_LO(start_addr));\ +} + +#else +#define hw_set_input_ring_start_addr(job_ring, start_addr) \ +{ \ + SET_JR_REG(IRBA, job_ring, 0); \ + SET_JR_REG_LO(IRBA, job_ring, PHYS_ADDR_LO(start_addr));\ +} + +#define hw_set_output_ring_start_addr(job_ring, start_addr) \ +{ \ + SET_JR_REG(ORBA, job_ring, 0); \ + SET_JR_REG_LO(ORBA, job_ring, PHYS_ADDR_LO(start_addr));\ +} +#endif + +/* ORJR - Output Ring Jobs Removed Register shows how many jobs were + * removed from the Output Ring for processing by software. This is done after + * the software has processed the entries. + */ +#define hw_remove_entries(jr, no_entries) SET_JR_REG(ORJR, (jr), (no_entries)) + +/* IRSA - Input Ring Slots Available register holds the number of entries in + * the Job Ring's input ring. Once a job is enqueued, the value returned is + * decremented by the hardware by the number of jobs enqueued. + */ +#define hw_get_available_slots(jr) GET_JR_REG(IRSA, jr) + +/* ORSFR - Output Ring Slots Full register holds the number of jobs which were + * processed by the SEC and can be retrieved by the software. Once a job has + * been processed by software, the user will call hw_remove_one_entry in order + * to notify the SEC that the entry was processed. + */ +#define hw_get_no_finished_jobs(jr) GET_JR_REG(ORSFR, jr) + +/* + * Macros for manipulating JR registers + */ +#if CORE_BYTE_ORDER == CAAM_BYTE_ORDER +#define sec_read_32(addr) (*(volatile unsigned int *)(addr)) +#define sec_write_32(addr, val) (*(volatile unsigned int *)(addr) = (val)) + +#else +#define sec_read_32(addr) rte_bswap32((*(volatile unsigned int *)(addr))) +#define sec_write_32(addr, val) \ + (*(volatile unsigned int *)(addr) = rte_bswap32(val)) +#endif + +#if CAAM_BYTE_ORDER == __LITTLE_ENDIAN +#define sec_read_64(addr) (((u64)sec_read_32((u32 *)(addr) + 1) << 32) | \ + (sec_read_32((u32 *)(addr)))) + +#define sec_write_64(addr, val) { \ + sec_write_32((u32 *)(addr) + 1, (u32)((val) >> 32)); \ + sec_write_32((u32 *)(addr), (u32)(val)); \ +} +#else /* CAAM_BYTE_ORDER == __BIG_ENDIAN */ +#define sec_read_64(addr) (((u64)sec_read_32((u32 *)(addr)) << 32) | \ + (sec_read_32((u32 *)(addr) + 1))) + +#define sec_write_64(addr, val) { \ + sec_write_32((u32 *)(addr), (u32)((val) >> 32)); \ + sec_write_32((u32 *)(addr) + 1, (u32)(val)); \ +} +#endif + +#if defined(RTE_ARCH_ARM64) +#define sec_read_addr(a) sec_read_64((a)) +#define sec_write_addr(a, v) sec_write_64((a), (v)) +#else +#define sec_read_addr(a) sec_read_32((a)) +#define sec_write_addr(a, v) sec_write_32((a), (v)) +#endif + +#define JR_REG(name, jr) (CHAN_BASE(jr) + JR_REG_##name##_OFFSET) +#define JR_REG_LO(name, jr) (CHAN_BASE(jr) + JR_REG_##name##_OFFSET_LO) + +#define GET_JR_REG(name, jr) (sec_read_32(JR_REG(name, (jr)))) +#define GET_JR_REG_LO(name, jr) (sec_read_32(JR_REG_LO(name, (jr)))) + +#define SET_JR_REG(name, jr, value) \ + (sec_write_32(JR_REG(name, (jr)), value)) +#define SET_JR_REG_LO(name, jr, value) \ + (sec_write_32(JR_REG_LO(name, (jr)), value)) + +/* Lists the possible states for a job ring. */ +typedef enum sec_job_ring_state_e { + SEC_JOB_RING_STATE_STARTED, /* Job ring is initialized */ + SEC_JOB_RING_STATE_RESET, /* Job ring reset is in progress */ +} sec_job_ring_state_t; + +/* code or cmd block to caam */ +struct sec_cdb { + struct { + union { + uint32_t word; + struct { +#if RTE_BYTE_ORDER == RTE_BIG_ENDIAN + uint16_t rsvd63_48; + unsigned int rsvd47_39:9; + unsigned int idlen:7; +#else + unsigned int idlen:7; + unsigned int rsvd47_39:9; + uint16_t rsvd63_48; +#endif + } field; + } __rte_packed hi; + + union { + uint32_t word; + struct { +#if RTE_BYTE_ORDER == RTE_BIG_ENDIAN + unsigned int rsvd31_30:2; + unsigned int fsgt:1; + unsigned int lng:1; + unsigned int offset:2; + unsigned int abs:1; + unsigned int add_buf:1; + uint8_t pool_id; + uint16_t pool_buffer_size; +#else + uint16_t pool_buffer_size; + uint8_t pool_id; + unsigned int add_buf:1; + unsigned int abs:1; + unsigned int offset:2; + unsigned int lng:1; + unsigned int fsgt:1; + unsigned int rsvd31_30:2; +#endif + } field; + } __rte_packed lo; + } __rte_packed sh_hdr; + + uint32_t sh_desc[SEC_JOB_DESCRIPTOR_SIZE]; +}; + +struct caam_jr_qp { + struct sec_job_ring_t *ring; + uint64_t rx_pkts; + uint64_t rx_errs; + uint64_t rx_poll_err; + uint64_t tx_pkts; + uint64_t tx_errs; + uint64_t tx_ring_full; +}; + +struct sec_job_ring_t { + /* TODO: Add wrapper macro to make it obvious this is the consumer index + * on the output ring + */ + uint32_t cidx; /* Consumer index for job ring (jobs array). + * @note: cidx and pidx are accessed from + * different threads. Place the cidx and pidx + * inside the structure so that they lay on + * different cachelines, to avoid false sharing + * between threads when the threads run on + * different cores! + */ + /* TODO: Add wrapper macro to make it obvious this is the producer index + * on the input ring + */ + uint32_t pidx; /* Producer index for job ring (jobs array) */ + + phys_addr_t *input_ring;/* Ring of output descriptors received from SEC. + * Size of array is power of 2 to allow fast + * update of producer/consumer indexes with + * bitwise operations. + */ + + struct sec_outring_entry *output_ring; + /* Ring of output descriptors received from SEC. + * Size of array is power of 2 to allow fast + * update of producer/consumer indexes with + * bitwise operations. + */ + + uint32_t irq_fd; /* The file descriptor used for polling from + * user space for interrupts notifications + */ + uint32_t jr_mode; /* Model used by SEC Driver to receive + * notifications from SEC. Can be either + * of the three: #SEC_NOTIFICATION_TYPE_NAPI + * #SEC_NOTIFICATION_TYPE_IRQ or + * #SEC_NOTIFICATION_TYPE_POLL + */ + uint32_t napi_mode; /* Job ring mode if NAPI mode is chosen + * Used only when jr_mode is set to + * #SEC_NOTIFICATION_TYPE_NAPI + */ + void *register_base_addr; /* Base address for SEC's + * register memory for this job ring. + */ + uint8_t coalescing_en; /* notifies if coelescing is + * enabled for the job ring + */ + sec_job_ring_state_t jr_state; /* The state of this job ring */ + + struct rte_mempool *ctx_pool; /* per dev mempool for caam_jr_op_ctx */ + unsigned int max_nb_queue_pairs; + unsigned int max_nb_sessions; + struct caam_jr_qp qps[RTE_CAAM_MAX_NB_SEC_QPS]; /* i/o queue for sec */ +}; + +/* Union describing the possible error codes that + * can be set in the descriptor status word + */ +union hw_error_code { + uint32_t error; + union { + struct { + uint32_t ssrc:4; + uint32_t ssed_val:28; + } __rte_packed value; + struct { + uint32_t ssrc:4; + uint32_t res:28; + } __rte_packed no_status_src; + struct { + uint32_t ssrc:4; + uint32_t jmp:1; + uint32_t res:11; + uint32_t desc_idx:8; + uint32_t cha_id:4; + uint32_t err_id:4; + } __rte_packed ccb_status_src; + struct { + uint32_t ssrc:4; + uint32_t jmp:1; + uint32_t res:11; + uint32_t desc_idx:8; + uint32_t offset:8; + } __rte_packed jmp_halt_user_src; + struct { + uint32_t ssrc:4; + uint32_t jmp:1; + uint32_t res:11; + uint32_t desc_idx:8; + uint32_t desc_err:8; + } __rte_packed deco_src; + struct { + uint32_t ssrc:4; + uint32_t res:17; + uint32_t naddr:3; + uint32_t desc_err:8; + } __rte_packed jr_src; + struct { + uint32_t ssrc:4; + uint32_t jmp:1; + uint32_t res:11; + uint32_t desc_idx:8; + uint32_t cond:8; + } __rte_packed jmp_halt_cond_src; + } __rte_packed error_desc; +} __rte_packed; + +/* @brief Initialize a job ring/channel in SEC device. + * Write configuration register/s to properly initialize a job ring. + * + * @param [in] job_ring The job ring + * + * @retval 0 for success + * @retval other for error + */ +int hw_reset_job_ring(struct sec_job_ring_t *job_ring); + +/* @brief Reset a job ring/channel in SEC device. + * Write configuration register/s to reset a job ring. + * + * @param [in] job_ring The job ring + * + * @retval 0 for success + * @retval -1 in case job ring reset failed + */ +int hw_shutdown_job_ring(struct sec_job_ring_t *job_ring); + +/* @brief Handle a job ring/channel error in SEC device. + * Identify the error type and clear error bits if required. + * + * @param [in] job_ring The job ring + * @param [in] sec_error_code The job ring's error code + */ +void hw_handle_job_ring_error(struct sec_job_ring_t *job_ring, + uint32_t sec_error_code); + +/* @brief Handle a job ring error in the device. + * Identify the error type and printout a explanatory + * messages. + * + * @param [in] job_ring The job ring + * + */ +void hw_job_ring_error_print(struct sec_job_ring_t *job_ring, int code); + +/* @brief Set interrupt coalescing parameters on the Job Ring. + * @param [in] job_ring The job ring + * @param [in] irq_coalesing_timer Interrupt coalescing timer threshold. + * This value determines the maximum + * amount of time after processing a + * descriptor before raising an interrupt. + * @param [in] irq_coalescing_count Interrupt coalescing descriptor count + * threshold. + */ +int hw_job_ring_set_coalescing_param(struct sec_job_ring_t *job_ring, + uint16_t irq_coalescing_timer, + uint8_t irq_coalescing_count); + +/* @brief Enable interrupt coalescing on a job ring + * @param [in] job_ring The job ring + */ +int hw_job_ring_enable_coalescing(struct sec_job_ring_t *job_ring); + +/* @brief Disable interrupt coalescing on a job ring + * @param [in] job_ring The job ring + */ +int hw_job_ring_disable_coalescing(struct sec_job_ring_t *job_ring); + +#endif /* CAAM_JR_HW_SPECIFIC_H */ diff --git a/drivers/crypto/caam_jr/caam_jr_pvt.h b/drivers/crypto/caam_jr/caam_jr_pvt.h new file mode 100644 index 000000000..cc0aa65f1 --- /dev/null +++ b/drivers/crypto/caam_jr/caam_jr_pvt.h @@ -0,0 +1,285 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright 2017-2018 NXP + */ + +#ifndef CAAM_JR_PVT_H +#define CAAM_JR_PVT_H + +/* NXP CAAM JR PMD device name */ + +#define CAAM_JR_ALG_UNSUPPORT (-1) + +/* Minimum job descriptor consists of a oneword job descriptor HEADER and + * a pointer to the shared descriptor. + */ +#define MIN_JOB_DESC_SIZE (CAAM_CMD_SZ + CAAM_PTR_SZ) +#define CAAM_JOB_DESC_SIZE 13 + +/* CTX_POOL_NUM_BUFS is set as per the ipsec-secgw application */ +#define CTX_POOL_NUM_BUFS 32000 +#define CTX_POOL_CACHE_SIZE 512 + +#define DIR_ENC 1 +#define DIR_DEC 0 + +#define JR_MAX_NB_MAX_DIGEST 32 + +#define RTE_CAAM_JR_PMD_MAX_NB_SESSIONS 2048 + + +/* Return codes for SEC user space driver APIs */ +enum sec_return_code_e { + SEC_SUCCESS = 0, /* Operation executed successfully.*/ + SEC_INVALID_INPUT_PARAM, /* API received an invalid input + * parameter + */ + SEC_OUT_OF_MEMORY, /* Memory allocation failed. */ + SEC_DESCRIPTOR_IN_FLIGHT, /* API function indicates there are + * descriptors in flight + * for SEC to process. + */ + SEC_LAST_DESCRIPTOR_IN_FLIGHT, /* API function indicates there is one + * last descriptor in flight + * for SEC to process that. + */ + SEC_PROCESSING_ERROR, /* Indicates a SEC processing error + * occurred on a Job Ring which requires + * a SEC user space driver shutdown. Can + * be returned from sec_poll_job_ring(). + * Then the only other API that can be + * called after this error is + * sec_release(). + */ + SEC_DESC_PROCESSING_ERROR, /* Indicates a SEC descriptor processing + * error occurred on a Job Ring. Can be + * returned from sec_poll_job_ring(). + * The driver was able to reset job ring + * and job ring can be used like in a + * normal case. + */ + SEC_JR_IS_FULL, /* Job Ring is full. There is no more + * room in the JR for new descriptors. + * This can happen if the descriptor RX + * rate is higher than SEC's capacity. + */ + SEC_DRIVER_RELEASE_IN_PROGRESS, /* SEC driver shutdown is in progress, + * descriptors processing or polling is + * allowed. + */ + SEC_DRIVER_ALREADY_INITIALIZED, /* SEC driver is already initialized.*/ + SEC_DRIVER_NOT_INITIALIZED, /* SEC driver is NOT initialized. */ + SEC_JOB_RING_RESET_IN_PROGRESS, /* Job ring is resetting due to a + * per-descriptor SEC processing error + * ::SEC_desc_PROCESSING_ERROR. Reset is + * finished when sec_poll_job_ring() + * return. Then the job ring can be used + * again. + */ + SEC_RESET_ENGINE_FAILED, /* Resetting of SEC Engine by SEC Kernel + * Driver Failed + */ + SEC_ENABLE_IRQS_FAILED, /* Enabling of IRQs in SEC Kernel Driver + * Failed + */ + SEC_DISABLE_IRQS_FAILED, /* Disabling of IRQs in SEC Kernel + * Driver Failed + */ + /* END OF VALID VALUES */ + + SEC_RETURN_CODE_MAX_VALUE, /* Invalid value for return code. It is + * used to mark the end of the return + * code values. @note ALL new return + * code values MUST be added before + * ::SEC_RETURN_CODE_MAX_VALUE! + */ +}; + +enum caam_jr_op_type { + CAAM_JR_NONE, /* No Cipher operations*/ + CAAM_JR_CIPHER,/* CIPHER operations */ + CAAM_JR_AUTH, /* Authentication Operations */ + CAAM_JR_AEAD, /* Authenticated Encryption with associated data */ + CAAM_JR_IPSEC, /* IPSEC protocol operations*/ + CAAM_JR_PDCP, /* PDCP protocol operations*/ + CAAM_JR_PKC, /* Public Key Cryptographic Operations */ + CAAM_JR_MAX +}; + +struct caam_jr_session { + uint8_t dir; /* Operation Direction */ + enum rte_crypto_cipher_algorithm cipher_alg; /* Cipher Algorithm*/ + enum rte_crypto_auth_algorithm auth_alg; /* Authentication Algorithm*/ + enum rte_crypto_aead_algorithm aead_alg; /* AEAD Algorithm*/ + union { + struct { + uint8_t *data; /* pointer to key data */ + size_t length; /* key length in bytes */ + } aead_key; + struct { + struct { + uint8_t *data; /* pointer to key data */ + size_t length; /* key length in bytes */ + } cipher_key; + struct { + uint8_t *data; /* pointer to key data */ + size_t length; /* key length in bytes */ + } auth_key; + }; + }; + struct { + uint16_t length; + uint16_t offset; + } iv; /* Initialisation vector parameters */ + uint16_t auth_only_len; /* Length of data for Auth only */ + uint32_t digest_length; + struct ip ip4_hdr; + struct caam_jr_qp *qp; + struct sec_cdb *cdb; /* cmd block associated with qp */ + struct rte_mempool *ctx_pool; /* session mempool for caam_jr_op_ctx */ +}; + +/* + * 16-byte hardware scatter/gather table + */ + +#define SEC4_SG_LEN_EXT 0x80000000 /* Entry points to table */ +#define SEC4_SG_LEN_FIN 0x40000000 /* Last ent in table */ +#define SEC4_SG_BPID_MASK 0x000000ff +#define SEC4_SG_BPID_SHIFT 16 +#define SEC4_SG_LEN_MASK 0x3fffffff /* Excludes EXT and FINAL */ +#define SEC4_SG_OFFSET_MASK 0x00001fff + +struct sec4_sg_entry { + uint64_t ptr; + uint32_t len; + uint32_t bpid_offset; +}; + +#define MAX_SG_ENTRIES 16 +#define SG_CACHELINE_0 0 +#define SG_CACHELINE_1 4 +#define SG_CACHELINE_2 8 +#define SG_CACHELINE_3 12 + +/* Structure encompassing a job descriptor which is to be processed + * by SEC. User should also initialise this structure with the callback + * function pointer which will be called by driver after recieving proccessed + * descriptor from SEC. User data is also passed in this data structure which + * will be sent as an argument to the user callback function. + */ +struct job_descriptor { + uint32_t desc[CAAM_JOB_DESC_SIZE]; +}; + +struct caam_jr_op_ctx { + struct job_descriptor jobdes; + /* sg[0] output, sg[1] input, others are possible sub frames */ + struct sec4_sg_entry sg[MAX_SG_ENTRIES]; + struct rte_crypto_op *op; + struct rte_mempool *ctx_pool; /* mempool pointer for caam_jr_op_ctx */ + int64_t vtop_offset; + uint8_t digest[JR_MAX_NB_MAX_DIGEST]; +}; + +/** + * Checksum + * + * @param buffer calculate chksum for buffer + * @param len buffer length + * + * @return checksum value in host cpu order + */ +static inline uint16_t +calc_chksum(void *buffer, int len) +{ + uint16_t *buf = (uint16_t *)buffer; + uint32_t sum = 0; + uint16_t result; + + for (sum = 0; len > 1; len -= 2) + sum += *buf++; + + if (len == 1) + sum += *(unsigned char *)buf; + + sum = (sum >> 16) + (sum & 0xFFFF); + sum += (sum >> 16); + result = ~sum; + + return result; +} +struct uio_job_ring { + uint32_t jr_id; + uint32_t uio_fd; + void *register_base_addr; + int map_size; + int uio_minor_number; +}; + +int sec_cleanup(void); +int sec_configure(void); +struct uio_job_ring *config_job_ring(void); +void free_job_ring(uint32_t uio_fd); + +/* For Dma memory allocation of specified length and alignment */ +static inline void *caam_jr_dma_mem_alloc(size_t align, size_t len) +{ + return rte_malloc("mem_alloc", len, align); +} + +/* For freeing dma memory */ +static inline void caam_jr_dma_free(void *ptr) +{ + rte_free(ptr); +} + +static inline rte_iova_t +caam_jr_mem_vtop(void *vaddr) +{ + const struct rte_memseg *ms; + + ms = rte_mem_virt2memseg(vaddr, NULL); + if (ms) + return ms->iova + RTE_PTR_DIFF(vaddr, ms->addr); + return (size_t)NULL; +} + +static inline void * +caam_jr_dma_ptov(rte_iova_t paddr) +{ + return rte_mem_iova2virt(paddr); +} + +/* Virtual to physical address conversion */ +static inline rte_iova_t caam_jr_dma_vtop(void *ptr) +{ + //return rte_malloc_virt2iova(ptr); + return caam_jr_mem_vtop(ptr); +} + +/** @brief Request to SEC kernel driver to enable interrupts for + * descriptor finished processing + * Use UIO to communicate with SEC kernel driver: write command + * value that indicates an IRQ enable action into UIO file descriptor + * of this job ring. + * + * @param [in] uio_fd Job Ring UIO File descriptor + * @retval 0 for success + * @retval -1 value for error + */ +uint32_t caam_jr_enable_irqs(uint32_t uio_fd); + +/** @brief Request to SEC kernel driver to disable interrupts for descriptor + * finished processing + * Use UIO to communicate with SEC kernel driver: write command + * value that indicates an IRQ disable action into UIO file descriptor + * of this job ring. + * + * @param [in] uio_fd UIO File descripto + * @retval 0 for success + * @retval -1 value for error + * + */ +uint32_t caam_jr_disable_irqs(uint32_t uio_fd); + +#endif diff --git a/drivers/crypto/caam_jr/caam_jr_uio.c b/drivers/crypto/caam_jr/caam_jr_uio.c new file mode 100644 index 000000000..bc9ace07e --- /dev/null +++ b/drivers/crypto/caam_jr/caam_jr_uio.c @@ -0,0 +1,491 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright 2017-2018 NXP + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* RTA header files */ +#include +#include +#include + +#include +#include +#include + +/* Prefix path to sysfs directory where UIO device attributes are exported. + * Path for UIO device X is /sys/class/uio/uioX + */ +#define SEC_UIO_DEVICE_SYS_ATTR_PATH "/sys/class/uio" + +/* Subfolder in sysfs where mapping attributes are exported + * for each UIO device. Path for mapping Y for device X is: + * /sys/class/uio/uioX/maps/mapY + */ +#define SEC_UIO_DEVICE_SYS_MAP_ATTR "maps/map" + +/* Name of UIO device file prefix. Each UIO device will have a device file + * /dev/uioX, where X is the minor device number. + */ +#define SEC_UIO_DEVICE_FILE_NAME "/dev/uio" + +/* + * Name of UIO device. Each user space SEC job ring will have a corresponding + * UIO device with the name sec-channelX, where X is the job ring id. + * Maximum length is #SEC_UIO_MAX_DEVICE_NAME_LENGTH. + * + * @note Must be kept in synch with SEC kernel driver + * define #SEC_UIO_DEVICE_NAME ! + */ +#define SEC_UIO_DEVICE_NAME "fsl-jr" + +/* Maximum length for the name of an UIO device file. + * Device file name format is: /dev/uioX. + */ +#define SEC_UIO_MAX_DEVICE_FILE_NAME_LENGTH 30 + +/* Maximum length for the name of an attribute file for an UIO device. + * Attribute files are exported in sysfs and have the name formatted as: + * /sys/class/uio/uioX/ + */ +#define SEC_UIO_MAX_ATTR_FILE_NAME 100 + +/* Command that is used by SEC user space driver and SEC kernel driver + * to signal a request from the former to the later to disable job DONE + * and error IRQs on a certain job ring. + * The configuration is done at SEC Controller's level. + * @note Need to be kept in synch with #SEC_UIO_DISABLE_IRQ_CMD from + * linux/drivers/crypto/talitos.c ! + */ +#define SEC_UIO_DISABLE_IRQ_CMD 0 + +/* Command that is used by SEC user space driver and SEC kernel driver + * to signal a request from the former to the later to enable job DONE + * and error IRQs on a certain job ring. + * The configuration is done at SEC Controller's level. + * @note Need to be kept in synch with #SEC_UIO_ENABLE_IRQ_CMD from + * linux/drivers/crypto/talitos.c ! + */ +#define SEC_UIO_ENABLE_IRQ_CMD 1 + +/** Command that is used by SEC user space driver and SEC kernel driver + * to signal a request from the former to the later to do a SEC engine reset. + * @note Need to be kept in synch with #SEC_UIO_RESET_SEC_ENGINE_CMD from + * linux/drivers/crypto/talitos.c ! + */ +#define SEC_UIO_RESET_SEC_ENGINE_CMD 3 + +/* The id for the mapping used to export SEC's registers to + * user space through UIO devices. + */ +#define SEC_UIO_MAP_ID 0 + +static struct uio_job_ring g_uio_job_ring[MAX_SEC_JOB_RINGS]; +static int g_uio_jr_num; + +/** @brief Checks if a file name contains a certain substring. + * If so, it extracts the number following the substring. + * This function assumes a filename format of: [text][number]. + * @param [in] filename File name + * @param [in] match String to match in file name + * @param [out] number The number extracted from filename + * + * @retval true if file name matches the criteria + * @retval false if file name does not match the criteria + */ +static bool +file_name_match_extract(const char filename[], const char match[], int *number) +{ + char *substr = NULL; + + substr = strstr(filename, match); + if (substr == NULL) + return false; + + /* substring was found in + * read number following substring in + */ + sscanf(filename + strlen(match), "%d", number); + return true; +} + +/** @brief Reads first line from a file. + * Composes file name as: root/subdir/filename + * + * @param [in] root Root path + * @param [in] subdir Subdirectory name + * @param [in] filename File name + * @param [out] line The first line read from file. + * + * @retval 0 for succes + * @retval other value for error + */ +static int +file_read_first_line(const char root[], const char subdir[], + const char filename[], char *line) +{ + char absolute_file_name[SEC_UIO_MAX_ATTR_FILE_NAME]; + int fd = 0, ret = 0; + + /*compose the file name: root/subdir/filename */ + memset(absolute_file_name, 0, sizeof(absolute_file_name)); + snprintf(absolute_file_name, SEC_UIO_MAX_ATTR_FILE_NAME, + "%s/%s/%s", root, subdir, filename); + + fd = open(absolute_file_name, O_RDONLY); + SEC_ASSERT(fd > 0, fd, "Error opening file %s", + absolute_file_name); + + /* read UIO device name from first line in file */ + ret = read(fd, line, SEC_UIO_MAX_DEVICE_FILE_NAME_LENGTH); + close(fd); + + /* NULL-ify string */ + line[SEC_UIO_MAX_DEVICE_FILE_NAME_LENGTH - 1] = '\0'; + + if (ret <= 0) { + CAAM_JR_ERR("Error reading from file %s", absolute_file_name); + return ret; + } + + return 0; +} + +/** @brief Uses UIO control to send commands to SEC kernel driver. + * The mechanism is to write a command word into the file descriptor + * that the user-space driver obtained for each user-space SEC job ring. + * Both user-space driver and kernel driver must have the same understanding + * about the command codes. + * + * @param [in] UIO FD The UIO file descriptor + * @param [in] uio_command Command word + * + * @retval Result of write operation on the job ring's UIO file descriptor. + * Should be sizeof(int) for success operations. + * Other values can be returned and used, if desired to add special + * meaning to return values, but this has to be programmed in SEC + * kernel driver as well. No special return values are used. + */ +static int sec_uio_send_command(uint32_t uio_fd, int32_t uio_command) +{ + int ret; + + /* Use UIO file descriptor we have for this job ring. + * Writing a command code to this file descriptor will make the + * SEC kernel driver execute the desired command. + */ + ret = write(uio_fd, &uio_command, sizeof(int)); + return ret; +} + +/** @brief Request to SEC kernel driver to enable interrupts for + * descriptor finished processing + * Use UIO to communicate with SEC kernel driver: write command + * value that indicates an IRQ enable action into UIO file descriptor + * of this job ring. + * + * @param [in] uio_fd Job Ring UIO File descriptor + * @retval 0 for success + * @retval -1 value for error + */ +uint32_t caam_jr_enable_irqs(uint32_t uio_fd) +{ + int ret; + + /* Use UIO file descriptor we have for this job ring. + * Writing a command code to this file descriptor will make the + * SEC kernel driver enable DONE and Error IRQs for this job ring, + * at Controller level. + */ + ret = sec_uio_send_command(uio_fd, SEC_UIO_ENABLE_IRQ_CMD); + SEC_ASSERT(ret == sizeof(int), -1, + "Failed to request SEC engine to enable job done and " + "error IRQs through UIO control. UIO FD %d. Reset SEC driver!", + uio_fd); + CAAM_JR_DEBUG("Enabled IRQs on jr with uio_fd %d", uio_fd); + return 0; +} + + +/** @brief Request to SEC kernel driver to disable interrupts for descriptor + * finished processing + * Use UIO to communicate with SEC kernel driver: write command + * value that indicates an IRQ disable action into UIO file descriptor + * of this job ring. + * + * @param [in] uio_fd UIO File descripto + * @retval 0 for success + * @retval -1 value for error + * + */ +uint32_t caam_jr_disable_irqs(uint32_t uio_fd) +{ + int ret; + + /* Use UIO file descriptor we have for this job ring. + * Writing a command code to this file descriptor will make the + * SEC kernel driver disable IRQs for this job ring, + * at Controller level. + */ + + ret = sec_uio_send_command(uio_fd, SEC_UIO_DISABLE_IRQ_CMD); + SEC_ASSERT(ret == sizeof(int), -1, + "Failed to request SEC engine to disable job done and " + "IRQs through UIO control. UIO_FD %d Reset SEC driver!", + uio_fd); + CAAM_JR_DEBUG("Disabled IRQs on jr with uio_fd %d", uio_fd); + return 0; +} + +/** @brief Maps register range assigned for a job ring. + * + * @param [in] uio_device_fd UIO device file descriptor + * @param [in] uio_device_id UIO device id + * @param [in] uio_map_id UIO allows maximum 5 different mapping for + each device. Maps start with id 0. + * @param [out] map_size Map size. + * @retval NULL if failed to map registers + * @retval Virtual address for mapped register address range + */ +static void * +uio_map_registers(int uio_device_fd, int uio_device_id, + int uio_map_id, int *map_size) +{ + void *mapped_address = NULL; + unsigned int uio_map_size = 0; + char uio_sys_root[SEC_UIO_MAX_ATTR_FILE_NAME]; + char uio_sys_map_subdir[SEC_UIO_MAX_ATTR_FILE_NAME]; + char uio_map_size_str[32]; + int ret = 0; + + /* compose the file name: root/subdir/filename */ + memset(uio_sys_root, 0, sizeof(uio_sys_root)); + memset(uio_sys_map_subdir, 0, sizeof(uio_sys_map_subdir)); + memset(uio_map_size_str, 0, sizeof(uio_map_size_str)); + + /* Compose string: /sys/class/uio/uioX */ + sprintf(uio_sys_root, "%s/%s%d", SEC_UIO_DEVICE_SYS_ATTR_PATH, + "uio", uio_device_id); + /* Compose string: maps/mapY */ + sprintf(uio_sys_map_subdir, "%s%d", SEC_UIO_DEVICE_SYS_MAP_ATTR, + uio_map_id); + + /* Read first (and only) line from file + * /sys/class/uio/uioX/maps/mapY/size + */ + ret = file_read_first_line(uio_sys_root, uio_sys_map_subdir, + "size", uio_map_size_str); + SEC_ASSERT(ret == 0, NULL, "file_read_first_line() failed"); + + /* Read mapping size, expressed in hexa(base 16) */ + uio_map_size = strtol(uio_map_size_str, NULL, 16); + + /* Map the region in user space */ + mapped_address = mmap(0, /*dynamically choose virtual address */ + uio_map_size, PROT_READ | PROT_WRITE, + MAP_SHARED, uio_device_fd, 0); + /* offset = 0 because UIO device has only one mapping + * for the entire SEC register memory + */ + if (mapped_address == MAP_FAILED) { + CAAM_JR_ERR( + "Failed to map registers! errno = %d job ring fd = %d," + "uio device id = %d, uio map id = %d", errno, + uio_device_fd, uio_device_id, uio_map_id); + return NULL; + } + + /* + * Save the map size to use it later on for munmap-ing. + */ + *map_size = uio_map_size; + + CAAM_JR_INFO("UIO dev[%d] mapped region [id =%d] size 0x%x at %p", + uio_device_id, uio_map_id, uio_map_size, mapped_address); + + return mapped_address; +} + +void free_job_ring(uint32_t uio_fd) +{ + struct uio_job_ring *job_ring = NULL; + int i; + + if (!job_ring->uio_fd) + return; + + for (i = 0; i < MAX_SEC_JOB_RINGS; i++) { + if (g_uio_job_ring[i].uio_fd == uio_fd) { + job_ring = &g_uio_job_ring[i]; + break; + } + } + if (job_ring == NULL) { + CAAM_JR_ERR("JR not available for fd = %x\n", uio_fd); + return; + } + + /* Open device file */ + CAAM_JR_INFO("Closed device file for job ring %d , fd = %d", + job_ring->jr_id, job_ring->uio_fd); + close(job_ring->uio_fd); + g_uio_jr_num--; + job_ring->uio_fd = 0; + + if (job_ring->register_base_addr == NULL) + return; + + /* Unmap the PCI memory resource of device */ + if (munmap(job_ring->register_base_addr, job_ring->map_size)) { + CAAM_JR_INFO("cannot munmap(%p, 0x%lx): %s", + job_ring->register_base_addr, + (unsigned long)job_ring->map_size, strerror(errno)); + } else + CAAM_JR_DEBUG(" JR UIO memory unmapped at %p", + job_ring->register_base_addr); + job_ring->register_base_addr = NULL; +} + +struct uio_job_ring *config_job_ring(void) +{ + char uio_device_file_name[32]; + struct uio_job_ring *job_ring = NULL; + int i; + + for (i = 0; i < MAX_SEC_JOB_RINGS; i++) { + if (g_uio_job_ring[i].uio_fd == 0) { + job_ring = &g_uio_job_ring[i]; + g_uio_jr_num++; + break; + } + } + + if (job_ring == NULL) { + CAAM_JR_ERR("No free job ring\n"); + return NULL; + } + + /* Find UIO device created by SEC kernel driver for this job ring. */ + memset(uio_device_file_name, 0, sizeof(uio_device_file_name)); + + sprintf(uio_device_file_name, "%s%d", SEC_UIO_DEVICE_FILE_NAME, + job_ring->uio_minor_number); + + /* Open device file */ + job_ring->uio_fd = open(uio_device_file_name, O_RDWR); + SEC_ASSERT(job_ring->uio_fd > 0, NULL, + "Failed to open UIO device file for job ring %d", + job_ring->jr_id); + + CAAM_JR_INFO("Open device(%s) file for job ring=%d , uio_fd = %d", + uio_device_file_name, job_ring->jr_id, job_ring->uio_fd); + + ASSERT(job_ring->register_base_addr == NULL); + job_ring->register_base_addr = uio_map_registers( + job_ring->uio_fd, job_ring->uio_minor_number, + SEC_UIO_MAP_ID, &job_ring->map_size); + + SEC_ASSERT(job_ring->register_base_addr != NULL, NULL, + "Failed to map SEC registers"); + return job_ring; +} + +int sec_configure(void) +{ + char uio_name[32]; + int config_jr_no = 0, jr_id = -1; + int uio_minor_number = -1; + int ret; + DIR *d = NULL; + struct dirent *dir; + + d = opendir(SEC_UIO_DEVICE_SYS_ATTR_PATH); + if (d == NULL) { + printf("\nError opening directory '%s': %s\n", + SEC_UIO_DEVICE_SYS_ATTR_PATH, strerror(errno)); + return -1; + } + + /* Iterate through all subdirs */ + while ((dir = readdir(d)) != NULL) { + if (!strncmp(dir->d_name, ".", 1) || + !strncmp(dir->d_name, "..", 2)) + continue; + + if (file_name_match_extract + (dir->d_name, "uio", &uio_minor_number)) { + /* + * Open file uioX/name and read first line which contains + * the name for the device. Based on the name check if this + * UIO device is UIO device for job ring with id jr_id. + */ + memset(uio_name, 0, sizeof(uio_name)); + ret = file_read_first_line(SEC_UIO_DEVICE_SYS_ATTR_PATH, + dir->d_name, "name", uio_name); + CAAM_JR_INFO("sec device uio name: %s", uio_name); + SEC_ASSERT(ret == 0, -1, "file_read_first_line failed"); + + if (file_name_match_extract(uio_name, + SEC_UIO_DEVICE_NAME, + &jr_id)) { + g_uio_job_ring[config_jr_no].jr_id = jr_id; + g_uio_job_ring[config_jr_no].uio_minor_number = + uio_minor_number; + CAAM_JR_INFO("Detected logical JRID:%d", jr_id); + config_jr_no++; + + /* todo find the actual ring id + * OF_FULLNAME=/soc/crypto@1700000/jr@20000 + */ + } + } + } + closedir(d); + + if (config_jr_no == 0) { + CAAM_JR_ERR("! No SEC Job Rings assigned for userspace usage!"); + return 0; + } + CAAM_JR_INFO("Total JR detected =%d", config_jr_no); + return config_jr_no; +} + +int sec_cleanup(void) +{ + int i; + struct uio_job_ring *job_ring; + + for (i = 0; i < g_uio_jr_num; i++) { + job_ring = &g_uio_job_ring[i]; + /* munmap SEC's register memory */ + if (job_ring->register_base_addr) { + munmap(job_ring->register_base_addr, + job_ring->map_size); + job_ring->register_base_addr = NULL; + } + /* I need to close the fd after shutdown UIO commands need to be + * sent using the fd + */ + if (job_ring->uio_fd != 0) { + CAAM_JR_INFO( + "Closed device file for job ring %d , fd = %d", + job_ring->jr_id, job_ring->uio_fd); + close(job_ring->uio_fd); + } + } + return 0; +} diff --git a/drivers/crypto/caam_jr/meson.build b/drivers/crypto/caam_jr/meson.build index 3edd0a212..7b024e886 100644 --- a/drivers/crypto/caam_jr/meson.build +++ b/drivers/crypto/caam_jr/meson.build @@ -6,6 +6,9 @@ if host_machine.system() != 'linux' endif deps += ['bus_vdev', 'bus_dpaa', 'security'] -sources = files('caam_jr.c') +sources = files('caam_jr_hw.c', 'caam_jr_uio.c', 'caam_jr.c') allow_experimental_apis = true + +includes += include_directories('../dpaa2_sec/') +includes += include_directories('../../bus/dpaa/include/') From patchwork Thu Sep 13 06:08:40 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Gagandeep Singh X-Patchwork-Id: 44640 X-Patchwork-Delegate: gakhil@marvell.com Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 0A50B58FE; Thu, 13 Sep 2018 08:09:40 +0200 (CEST) Received: from EUR02-VE1-obe.outbound.protection.outlook.com (mail-eopbgr20074.outbound.protection.outlook.com [40.107.2.74]) by dpdk.org (Postfix) with ESMTP id 2B2275592 for ; Thu, 13 Sep 2018 08:09:31 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=sDYqw5pVCChmD0OKhIJDY0iIdS9PrmwKGbUVvCL1bgw=; b=dq7mancOmIyOBnXCbyzjMPu3BwHqMcW8QJIhu+rjz3GRP3KsnFm2lbivu6Gxh1pVatvvW57/aSRIbc6Hk/jBe0uY5eZvZ3rBm4NOfjitN4/TslZgS6m/1V3V5d6PPHHmku02GPmUepmAS2NDMhBeK4vzeSd82UI6gP53BtLJCIU= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=G.Singh@nxp.com; Received: from Tophie.ap.freescale.net (14.142.187.166) by HE1PR04MB1529.eurprd04.prod.outlook.com (2a01:111:e400:59a8::19) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1143.15; Thu, 13 Sep 2018 06:09:28 +0000 From: Gagandeep Singh To: dev@dpdk.org, akhil.goyal@nxp.com Cc: Hemant Agrawal , Gagandeep Singh Date: Thu, 13 Sep 2018 11:38:40 +0530 Message-Id: <20180913060846.29930-5-g.singh@nxp.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20180913060846.29930-1-g.singh@nxp.com> References: <20180913060846.29930-1-g.singh@nxp.com> MIME-Version: 1.0 X-Originating-IP: [14.142.187.166] X-ClientProxiedBy: BM1PR01CA0095.INDPRD01.PROD.OUTLOOK.COM (2603:1096:b00::11) To HE1PR04MB1529.eurprd04.prod.outlook.com (2a01:111:e400:59a8::19) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: b1242390-c0df-48c2-912f-08d6193f772a X-MS-Office365-Filtering-HT: Tenant X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989137)(4534165)(7168020)(4627221)(201703031133081)(201702281549075)(8990107)(5600074)(711020)(4618075)(2017052603328)(7153060)(7193020); SRVR:HE1PR04MB1529; X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 3:2C2toBe9hwsurp1J/FDhBaxRVHHnsIuy+M84z/Qq2eXEp0btOMuU49xr3RldZob4xfVjc/P18xn40jvRNv75bYgTBQrS5tjLvHIz2Pp/DKIo//AItWCRf24wzM+lvc08+HDgn6h8XaZh2XGRWILv1Y5I64lPmetbj73iQYHEjBl/0yeTXIbRD1qsr1YzQfTXxXkEMSWvZL7tqoTZJMVleOwGKic+rCuJIqbEctFywayh/pgZkJ9yO6edcU9Amfbc; 25:8vqCPkLM+Ihu9+ZKe/NEWQwMXIi5wEpMzHLpumaBtyEoXVmqPX88OYZC1sTiFtFIPJ1wuG4jyFbU9EvaWd+HrGAFpZO5jl+7g8oPFvohxk8lU7x0EoMtv1f4+obWY4+z6bIarQeGTmo3WTvFaO4xCSVvzQMLyQf9JagbNlnuzg4LKUAOtcils8T84iUEheeDA+/q0GvPhqJ39UwIzmiTjwsQlq5ETHEtGiayhGB4ZA6xz0GS3ZXwdgdRG8Hs+/Em7g3/S604xZhFJbDvr9GKCKlt9pwTl/jLZfPQw0tHRsLwMrgdzhbbW7kgw3nNdidDgbjas5M7RT8Ck+rrNZFciA==; 31:Dqhmq3CrxSQ+tKK44B25VkzyYq9Vk3y+beFK/UECwwnesLF6hV0Fcyp8nWKvwxEK02YhMqev+THlTWGqPRjVuS2UEJ/4ZFYGbl5GecA8V6Z13t5dKoF2bmDOHOYZq2fKSZrHcaLPhSVZYP/Plfe4uE4MWExLVMlXVsI7OA3r2q1JCcrMxZ0P5KNT8D88+LQtve1V91ghapoUqNXm49nXFpMDBcTwnRfptGCoZr4Tlcw= X-MS-TrafficTypeDiagnostic: HE1PR04MB1529: X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 20:nCHIAXfWzKUOeDAEGA4CxHJBzXARatkrnXvfc+m3jclQ+4apA0ovPaJht69po+X02eymdb9MWEm8NmiHNrR6oZBtBqelk85+Tx1iVndvN/l/+WCarvHndWsQ9Qm42/ROJBQJqfk7818YqBAuW7/lA4WwG7i0XOZrQsnIKebxixjlO/W91hopywBI2DDqItvI9KuJlE7KxqJFO4X9xjN3fhlFcn1a85drXDhaNpbBeXliN5DJlpUF6eCrpVeFXGbVs9K1VUTqoTHvOEQI/z+jlNRsOykdQJ5hl3kkD8+jqs6Zs5T2SKwHQ+k6iG5rhjNq00Tm3kK/k47SGfwa+kqNcd6e8O7LLidCwXjkNPD0OAy0vSVAelVRtni5vyeg7+E0mDNiCQxNsFx0X9c7znpKijJLe4r20m7PXdLgKVgowCYKfJ0QtJPRicmuc5LYaEXbaZ7kTsdAtmDYucjFFWNEdSIGjV4U5GuTlJm3Oa2XaLRLzCHK3FMgk/9f9DNHi8SU; 4:rBLESxUUHPIaKJy65xeHl/LZjdycAJM+3fcorevDGbg+F/xPdZTmcESYC33GUblPTv1H8M/tE3aCCGL6EPWJbAkTNzG1P1C7ZiF+uGynE1N1r2D0j3GTm/7QsuY5CTjmoXUDH+CqkFyXDpT1Rbq8t+2dofz+nEiNACVkKj0MyNYnGj+xkZpxtMI8ZBfSH5w5Ctg5WxvsIkjScgkXlXDM5mMnZhuyNC/TRuew/li5ZhOs4BuR6qqBx2is84cmjPZjUN+WbWy3Xvage8VcrVM7DqnfgcU/P6V15ZHKi5melgzeqykjqYQ5LUIOh+F6X1x1 X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(185117386973197); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(5005006)(8121501046)(823301075)(3231311)(944501410)(52105095)(3002001)(93006095)(93001095)(10201501046)(6055026)(149027)(150027)(6041310)(20161123558120)(20161123562045)(20161123560045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123564045)(201708071742011)(7699050); SRVR:HE1PR04MB1529; BCL:0; PCL:0; RULEID:; SRVR:HE1PR04MB1529; X-Forefront-PRVS: 07943272E1 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(366004)(376002)(39860400002)(136003)(346002)(396003)(189003)(199004)(2906002)(6506007)(386003)(5009440100003)(6486002)(51416003)(6512007)(52116002)(486006)(2616005)(68736007)(956004)(53936002)(476003)(446003)(11346002)(305945005)(26005)(7736002)(55236004)(76176011)(186003)(16526019)(50226002)(478600001)(47776003)(1076002)(3846002)(6116002)(48376002)(105586002)(106356001)(25786009)(14444005)(50466002)(5660300001)(36756003)(72206003)(66066001)(316002)(97736004)(8936002)(81166006)(4326008)(8676002)(86362001)(6636002)(6666003)(54906003)(81156014)(16586007)(110426005); DIR:OUT; SFP:1101; SCL:1; SRVR:HE1PR04MB1529; H:Tophie.ap.freescale.net; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: nxp.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; HE1PR04MB1529; 23:tmJ9Ve1aBMtEmBFU9+ho0oiinmdPmkVwoQamk4Ki8?= MCsyiH4zrY6DQBH5z55jZMPtBJhRK8lO/YMWbuECthbTvMsWH9F0EoXUKKx2oqObcopwyvtHsQMdi3u65g1bIqcbZC2lTPFMZjkcSfoHS9HxTpyERMEW9lWgTKcJ0PKaqQIWWk7YU0aFjAau7BnmqKCgs2YC1ROs9Dh98Yw0B74UCgCt9QN83/NxPDUqu4haxunxtdWBy96FlJo8NlUHVjLfcO2dwZEFIxCI8oZIbiG8TZcYG6KxuxKcZ6qLcODwpNhxDFtAsSVaDRWnEBB08SHyoHPd2/SCNiB9yqNQvKltV11ORt/x+FwvDI9jCcv/s3P7MRKkCyGbJ6rqIrzBA6+8NqAwho5I7awi2TXcLmRjiJKj+5TvWaOecgY5y79E+g7Ag2cu9YfC/wzHW2wXrREqEdHGBLSv7QDHKuBMgk/toSnP9lYWejyVXj8ruPhP7ljMQk9Z8AFeCRJkPVHqsj98IUcYmupko0YC1LLdhlbWF4C7PZGcOZTASsAPZxlMNtuAhJIkPDtjPkavhuTgh13bpmDsLG6OvY7Itl3ZM2X2OsnI6zZahdN9c/HSxzMUCS2xRwMZ9P5Q9NnueP5L6nnHRdYLHftbHEPSZZcKNTeAmT+eJXhrtC3Df845n/M+A/1dyiOpqcZJyZ1fYNnSGp2k7MWwEawkyuPz9sdClNQVmUcmuwmG/CjIGUvLfhJIJNQOGBUcoCjuX/WtDWItzwjygU2UvvBNveQlIyY5ez3uk4id00tZfWqkxiXGY1h07IjL3PPYOKMb2BznHL2Z8QkcjJlt8AXw+L/QI37i14x5Cpvn0KO3P0QImE/PCoM+F4rE9TcrL8mhSHx7uJNzFvRNYq7SDWASAc4y2CM02qq3ePK0NgaAmdqDDsmLT7M6HoHWad+7hHgkTycpX53pNP/jG8Ccs3/BllyuYQn5CkFL+vVKApY+fagwcwclnK7KMGCU8y5vT0OR264VCRU/SXYDnk68HkWoGl0ewlj2lhRQrhQbCr3LgO9ZhW5PlgX0l4ZimZsowlv9Aix8lcK8XwkGUTkdDczp+KGUQ++UsLmvjqOvqGsspyNOOP1+l7ZvC/98/0vgEZME5Lx7Z61bUaPu+GzrgBIR+AQl0utOwg4A1LHbYAKoEH2npewKcf6nRw8IqZRmAksPLkhQ8w0diELCTwhdt/NuFuAlt3JTKQ6LKwzsIPDcIiJYaXJQVCTMsxOgsv0p9T/aRCk4mWLKifuCYep03VhK9hb1ULItGrdtiYJRLYHnHV89BWwC2krkPVDSASlLihj/iQUs3MrcFXj X-Microsoft-Antispam-Message-Info: +DdztoEE9uzMmB4T/Q0KIvw3Alf9a/0JMEBHIVV4cqdfs6/tdvDNDoOP3URiBbKX2pOoHI/bsSWw9otv60QHEKyM1iquvSBeRJxMQh66o5d6t1WseUqV24qlg47tOHmJmZ4uDU80LseV3qelGx73GVXYBFBmTMsjKrsY84LLUZkLYMWjoiOH2k8Q02xaYa8QzknDUcfqJnA7jJ8QkzH/63XcKMJKR3xBqlItNDbroN01hp/8pe7dZql5ajD5xG9MvdKZAxAelz62zCKe+iTUeMOFJl5FRGW7FOxZdvnuo/U1Vl1t24lGjTdwKaEpQ+06Zw5+mUAr6O3vVyxZVeAYrr0kwriCvpJGWVuGFV1JUWQ= X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 6:B7uDqctSI9eGRN0Z2W+B9kfqh1Iv6anijiqJEXcimLpgubXrMn5S88ajk1X/IXNfRLiY9m4zhw78RCDWwEVyZobMABSRTXhgQd2nLPKwlXkcKcZ/j1RLwhBB2kDlWZT5d/XoBSESek+qFyWzBo+c5D9/kK4JbqkrGc/vocbbRtUO8pUsEY7swWL6VjZuCoQEWCqOgzqOOjakBTTPRTpb5Vw6oWKRdEfRNMIsQtE4MD0Qhce3n3CO+VOUTH9ot+wVnNsKk7OFYssNhP2hOY06ljQ3Y3/IINCkUr2SnGleNzt6BXfmwc8F93VmGxQ4SAhG22e1arMrzeqgTuXEzeesn4v212mJvbfz+fIFPlTqiquQY1qTK7C8dyiHqLsb9t46Xd7LcznrNNeuTYFKPyyRXYT/WRslboCW5Sa0pe6E4pnJA250lZLWe0XEbJ/hXLEoihmZMYieuaAT7zPNKmWonA==; 5:LdZTfd+7FMmghlsE6zIndSpT6TG89cUc4P3BXMWkoHdZmoLOMcgrgOgsiHca2QQH6IeI2sC58wBWBbYU+ukLLxfXMv2N0fHsm9Zwc4Qu/XQARGb9i9pV45DS3CbhKhr1bIeFNAnt6nMHwDcFmXB60kB98jchoOjIhJWuNwsWmcw=; 7:bav5vzRFr9YYkJyOYR4Fe3Rdowhor2LMTQuQesw3q1xMj8WFS6lLxtzwJNes7fvB2Ks5w236LRkUGjQIVDW67ZSfD9H9p6UraJawybBbB+dXrE6dgSfWc8/NnEg1/5lT3grditg3Hrm0XlUntj7oPvvDn2QK2tau7/iH/53X3jI86l9UMykGSBIi9p4nn9qrK++mT/gdErg//XxxlDovog7dWbLhn9SGo36RdZgkZWtkleFMmd4rXejgLtdigCCH SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 13 Sep 2018 06:09:28.0696 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: b1242390-c0df-48c2-912f-08d6193f772a X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-Transport-CrossTenantHeadersStamped: HE1PR04MB1529 Subject: [dpdk-dev] [PATCH 04/10] crypto/caam_jr: add device configuration routines 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" From: Hemant Agrawal Signed-off-by: Gagandeep Singh Signed-off-by: Hemant Agrawal --- drivers/crypto/caam_jr/caam_jr.c | 100 +++++++++++- drivers/crypto/caam_jr/caam_jr.h | 257 +++++++++++++++++++++++++++++++ 2 files changed, 356 insertions(+), 1 deletion(-) create mode 100644 drivers/crypto/caam_jr/caam_jr.h diff --git a/drivers/crypto/caam_jr/caam_jr.c b/drivers/crypto/caam_jr/caam_jr.c index 9d5f5b79b..43fe5233b 100644 --- a/drivers/crypto/caam_jr/caam_jr.c +++ b/drivers/crypto/caam_jr/caam_jr.c @@ -22,6 +22,7 @@ #include #include #include +#include #include #include @@ -104,6 +105,90 @@ static void hw_flush_job_ring(struct sec_job_ring_t *job_ring, } +static int +caam_jr_dev_configure(struct rte_cryptodev *dev, + struct rte_cryptodev_config *config __rte_unused) +{ + char str[20]; + struct sec_job_ring_t *internals; + + PMD_INIT_FUNC_TRACE(); + + internals = dev->data->dev_private; + sprintf(str, "ctx_pool_%d", dev->data->dev_id); + if (!internals->ctx_pool) { + internals->ctx_pool = rte_mempool_create((const char *)str, + CTX_POOL_NUM_BUFS, + sizeof(struct caam_jr_op_ctx), + CTX_POOL_CACHE_SIZE, 0, + NULL, NULL, NULL, NULL, + SOCKET_ID_ANY, 0); + if (!internals->ctx_pool) { + CAAM_JR_ERR("%s create failed\n", str); + return -ENOMEM; + } + } else + CAAM_JR_INFO("mempool already created for dev_id : %d", + dev->data->dev_id); + + return 0; +} + +static int +caam_jr_dev_start(struct rte_cryptodev *dev __rte_unused) +{ + PMD_INIT_FUNC_TRACE(); + return 0; +} + +static void +caam_jr_dev_stop(struct rte_cryptodev *dev __rte_unused) +{ + PMD_INIT_FUNC_TRACE(); +} + +static int +caam_jr_dev_close(struct rte_cryptodev *dev) +{ + struct sec_job_ring_t *internals; + + PMD_INIT_FUNC_TRACE(); + + if (dev == NULL) + return -ENOMEM; + + internals = dev->data->dev_private; + rte_mempool_free(internals->ctx_pool); + internals->ctx_pool = NULL; + + return 0; +} + +static void +caam_jr_dev_infos_get(struct rte_cryptodev *dev, + struct rte_cryptodev_info *info) +{ + struct sec_job_ring_t *internals = dev->data->dev_private; + + PMD_INIT_FUNC_TRACE(); + if (info != NULL) { + info->max_nb_queue_pairs = internals->max_nb_queue_pairs; + info->feature_flags = dev->feature_flags; + info->capabilities = caam_jr_capabilities; + info->sym.max_nb_sessions = internals->max_nb_sessions; + info->driver_id = cryptodev_driver_id; + } +} + +static struct rte_cryptodev_ops caam_jr_ops = { + .dev_configure = caam_jr_dev_configure, + .dev_start = caam_jr_dev_start, + .dev_stop = caam_jr_dev_stop, + .dev_close = caam_jr_dev_close, + .dev_infos_get = caam_jr_dev_infos_get, +}; + + /* @brief Flush job rings of any processed descs. * The processed descs are silently dropped, * WITHOUT being notified to UA. @@ -366,7 +451,20 @@ caam_jr_dev_init(const char *name, } dev->driver_id = cryptodev_driver_id; - dev->dev_ops = NULL; + dev->dev_ops = &caam_jr_ops; + + /* register rx/tx burst functions for data path */ + dev->dequeue_burst = NULL; + dev->enqueue_burst = NULL; + dev->feature_flags = RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO | + RTE_CRYPTODEV_FF_HW_ACCELERATED | + RTE_CRYPTODEV_FF_SYM_OPERATION_CHAINING | + RTE_CRYPTODEV_FF_SECURITY | + RTE_CRYPTODEV_FF_IN_PLACE_SGL | + RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT | + RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT | + RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT | + RTE_CRYPTODEV_FF_OOP_LB_IN_LB_OUT; /* For secondary processes, we don't initialise any further as primary * has already done this work. Only check we don't need a different diff --git a/drivers/crypto/caam_jr/caam_jr.h b/drivers/crypto/caam_jr/caam_jr.h new file mode 100644 index 000000000..d7c36ca9d --- /dev/null +++ b/drivers/crypto/caam_jr/caam_jr.h @@ -0,0 +1,257 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright 2017-2018 NXP + */ + +#ifndef CAAM_JR_H +#define CAAM_JR_H + +static const struct rte_cryptodev_capabilities caam_jr_capabilities[] = { + { /* MD5 HMAC */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, + {.auth = { + .algo = RTE_CRYPTO_AUTH_MD5_HMAC, + .block_size = 64, + .key_size = { + .min = 1, + .max = 64, + .increment = 1 + }, + .digest_size = { + .min = 1, + .max = 16, + .increment = 1 + }, + .iv_size = { 0 } + }, } + }, } + }, + { /* SHA1 HMAC */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, + {.auth = { + .algo = RTE_CRYPTO_AUTH_SHA1_HMAC, + .block_size = 64, + .key_size = { + .min = 1, + .max = 64, + .increment = 1 + }, + .digest_size = { + .min = 1, + .max = 20, + .increment = 1 + }, + .iv_size = { 0 } + }, } + }, } + }, + { /* SHA224 HMAC */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, + {.auth = { + .algo = RTE_CRYPTO_AUTH_SHA224_HMAC, + .block_size = 64, + .key_size = { + .min = 1, + .max = 64, + .increment = 1 + }, + .digest_size = { + .min = 1, + .max = 28, + .increment = 1 + }, + .iv_size = { 0 } + }, } + }, } + }, + { /* SHA256 HMAC */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, + {.auth = { + .algo = RTE_CRYPTO_AUTH_SHA256_HMAC, + .block_size = 64, + .key_size = { + .min = 1, + .max = 64, + .increment = 1 + }, + .digest_size = { + .min = 1, + .max = 32, + .increment = 1 + }, + .iv_size = { 0 } + }, } + }, } + }, + { /* SHA384 HMAC */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, + {.auth = { + .algo = RTE_CRYPTO_AUTH_SHA384_HMAC, + .block_size = 128, + .key_size = { + .min = 1, + .max = 128, + .increment = 1 + }, + .digest_size = { + .min = 1, + .max = 48, + .increment = 1 + }, + .iv_size = { 0 } + }, } + }, } + }, + { /* SHA512 HMAC */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, + {.auth = { + .algo = RTE_CRYPTO_AUTH_SHA512_HMAC, + .block_size = 128, + .key_size = { + .min = 1, + .max = 128, + .increment = 1 + }, + .digest_size = { + .min = 1, + .max = 64, + .increment = 1 + }, + .iv_size = { 0 } + }, } + }, } + }, + { /* AES GCM */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_AEAD, + {.aead = { + .algo = RTE_CRYPTO_AEAD_AES_GCM, + .block_size = 16, + .key_size = { + .min = 16, + .max = 32, + .increment = 8 + }, + .digest_size = { + .min = 8, + .max = 16, + .increment = 4 + }, + .aad_size = { + .min = 0, + .max = 240, + .increment = 1 + }, + .iv_size = { + .min = 12, + .max = 12, + .increment = 0 + }, + }, } + }, } + }, + { /* AES CBC */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER, + {.cipher = { + .algo = RTE_CRYPTO_CIPHER_AES_CBC, + .block_size = 16, + .key_size = { + .min = 16, + .max = 32, + .increment = 8 + }, + .iv_size = { + .min = 16, + .max = 16, + .increment = 0 + } + }, } + }, } + }, + { /* AES CTR */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER, + {.cipher = { + .algo = RTE_CRYPTO_CIPHER_AES_CTR, + .block_size = 16, + .key_size = { + .min = 16, + .max = 32, + .increment = 8 + }, + .iv_size = { + .min = 16, + .max = 16, + .increment = 0 + } + }, } + }, } + }, + { /* 3DES CBC */ + .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, + {.sym = { + .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER, + {.cipher = { + .algo = RTE_CRYPTO_CIPHER_3DES_CBC, + .block_size = 8, + .key_size = { + .min = 16, + .max = 24, + .increment = 8 + }, + .iv_size = { + .min = 8, + .max = 8, + .increment = 0 + } + }, } + }, } + }, + + RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST() +}; + +static const struct rte_security_capability caam_jr_security_cap[] = { + { /* IPsec Lookaside Protocol offload ESP Transport Egress */ + .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL, + .protocol = RTE_SECURITY_PROTOCOL_IPSEC, + .ipsec = { + .proto = RTE_SECURITY_IPSEC_SA_PROTO_ESP, + .mode = RTE_SECURITY_IPSEC_SA_MODE_TUNNEL, + .direction = RTE_SECURITY_IPSEC_SA_DIR_EGRESS, + .options = { 0 } + }, + .crypto_capabilities = caam_jr_capabilities + }, + { /* IPsec Lookaside Protocol offload ESP Tunnel Ingress */ + .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL, + .protocol = RTE_SECURITY_PROTOCOL_IPSEC, + .ipsec = { + .proto = RTE_SECURITY_IPSEC_SA_PROTO_ESP, + .mode = RTE_SECURITY_IPSEC_SA_MODE_TUNNEL, + .direction = RTE_SECURITY_IPSEC_SA_DIR_INGRESS, + .options = { 0 } + }, + .crypto_capabilities = caam_jr_capabilities + }, + { + .action = RTE_SECURITY_ACTION_TYPE_NONE + } +}; + +#endif From patchwork Thu Sep 13 06:08:41 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Gagandeep Singh X-Patchwork-Id: 44641 X-Patchwork-Delegate: gakhil@marvell.com Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id E21605A44; Thu, 13 Sep 2018 08:09:41 +0200 (CEST) Received: from EUR02-VE1-obe.outbound.protection.outlook.com (mail-eopbgr20063.outbound.protection.outlook.com [40.107.2.63]) by dpdk.org (Postfix) with ESMTP id 9F74056A3 for ; Thu, 13 Sep 2018 08:09:32 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=dtdB71x1kjuu21jx2haFNLimF507R4qwFFUjaNOYLC4=; b=uh5uRbxNmvWEFQru7RsZiGqNhdH3s7nQdKNhWak8/amsiwtEpBd09hpL8pBA8hE4eAxwSBcbROp6l/4Y9EBDGBCjfl+AqH0hLOXDA3ikWlmQlJw7z5fj7MYbF3/HQi39CeqXPN245dlUpRmQaX1lifjDYky5yzHYsSDzzhEDxSg= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=G.Singh@nxp.com; Received: from Tophie.ap.freescale.net (14.142.187.166) by HE1PR04MB1529.eurprd04.prod.outlook.com (2a01:111:e400:59a8::19) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1143.15; Thu, 13 Sep 2018 06:09:29 +0000 From: Gagandeep Singh To: dev@dpdk.org, akhil.goyal@nxp.com Cc: Hemant Agrawal , Gagandeep Singh Date: Thu, 13 Sep 2018 11:38:41 +0530 Message-Id: <20180913060846.29930-6-g.singh@nxp.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20180913060846.29930-1-g.singh@nxp.com> References: <20180913060846.29930-1-g.singh@nxp.com> MIME-Version: 1.0 X-Originating-IP: [14.142.187.166] X-ClientProxiedBy: BM1PR01CA0095.INDPRD01.PROD.OUTLOOK.COM (2603:1096:b00::11) To HE1PR04MB1529.eurprd04.prod.outlook.com (2a01:111:e400:59a8::19) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 651f06fa-59c6-4956-eb69-08d6193f7824 X-MS-Office365-Filtering-HT: Tenant X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989137)(4534165)(7168020)(4627221)(201703031133081)(201702281549075)(8990107)(5600074)(711020)(4618075)(2017052603328)(7153060)(7193020); SRVR:HE1PR04MB1529; X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 3:j52s+PSAItVWyCT3zwIHjAaaQkcxvZVXvqymLPhknq2GKgwRIY/ioNeVsnmpj+n8lNi0woi5ghTPcq75LHJA/dfNZCZLZKJFw0FmFtzcX6XA4I3eaR7lESmFlSQYp172eHqYwivSGfPzGPsssC6r0CmF/NqRD5rR+Am1FdPhdcWKLVqOARY8MSuy5SNFMyUY6b0F7Hfv7Dj2qi90eGi8tWwFzM50hBmbg3jKFY9vb//uN5X8aDvZrdQ3+RAVtRvF; 25:MVcVsLGLC5bUlvyJbGcXlzw9lO6MIGLf8YfZ6PyC1Ab50uRRMoJFBFPPA4DKVWwhp+xKBiJLJiZ8/hPaKwcwbjnjaM+tHY9Lx9GE6SwSn9QScK5OHtkJ7ZZAnZaMCVZy+yyudvH4L/FNmP7qeO8Z56Hk96LXkIFrj/WIOBkEJyRIkQlgi1ey6/4Y8EO5Ihh4Fyvj6E6fvxvHp7QRc6DzfOwYC470liyLjLWBx4oUORRoJIq7JyR7XfDbOFU23kIRJcPh8rbyvrk+OpT7Izh6r8vAH5y2hDLw9e1MYN0SQem7fBmO9xCsjDKRRTN1jMeqjQLB1NL6XoAOh+72yqATEg==; 31:dvWIyxlxwuLVYfbvtHZt+AT1zMO8uXaPkFu5C2xyBBLep60ainHr2gsvi1mvDm9M3DO2P37zUUFwfRO0Ygpu8vgGBTDh3jCZ8BfByiqiKYWha1+0RlQW1P0F078khqXznGkPxIJz4LOsuEqjKnmnCiqc8GNFL0NEP+kM0j2YFNgxKL2OK1/uAqG5Wvf+8G4e6yxKSd/ssdUl8g5ZrSTzcrhVdjMaji4bU8iqIOifjD8= X-MS-TrafficTypeDiagnostic: HE1PR04MB1529: X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 20:mcopWFHkmqRkHwOlD+0pQURlgPvL/KPbtvUiFQnmywn2NCCaJSVw95uvRmJ+CllXp+5o8NwIFSjcGk3BkWqbO266HKLrFylzwhZF3pC/8dJEZEnEZ1INAWAi4JcDgdwPy7JAR2dlWJTVv+FSsk+Eih24tWXpAzhVMZWnespk8vIaBT3OkwfqqBwmBcfTGl2YQEC+D7Y2V/ehLu40cqRO4v1l4ZIlv2oYW7J4Cu7l7+CoRIWL/oV7BVCNQ1bsW+dIIX4/kQdlCL8KSOwLGWA4wkjSyzaagSGkoZ5vICN7GMH4zObhi5+7ZBErR0Ab4fS4islVcki8ptDX8zEM9i3Qw0FzzKEGBLKCEgQ1LENfQnh5PFGI6YzXVdckelxqZnANb4x3zYVa0T+021HRIO6PQX/97kk8KOCZzFoNez8RpzqLLr4srp3jSb1IJzyewnR8Bh1WHCtcgVqgmJiZJfzVLHJP06ynKnU8I7YrPQcjDthZTP0aWbtHawjIxlzKuAms; 4:5BFptogfuu/NoFvTv84TPRaGCf9dKuH5ntEOI1IfuVfHbN6KMSDEuEiR9Hg2TCwNbfrhA49K0Se59wdcXAfO8rUJbAMdvp4kWc9Yw7cQZS8916YDgsVfsMnkQBgZMX7Jg2AyiB+7Fw6mZHlxRlL1z3Snix1tQ02DrWuNTER907bA4DhNNkyOE3pn9RJHd/0SFsC6PBPvYhmyGRgmjzIjW3HlxCsYUApklHVZtsVZTDKxtTeW3hCQsj/Di8iMtnD2+IMTWjqOkAoA4T47ztXEnesdlyjtTgg0pftIU9sB2ixRLDSGjlkG8mFcFqBb5i3P X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(185117386973197); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(5005006)(8121501046)(823301075)(3231311)(944501410)(52105095)(3002001)(93006095)(93001095)(10201501046)(6055026)(149027)(150027)(6041310)(20161123558120)(20161123562045)(20161123560045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123564045)(201708071742011)(7699050); SRVR:HE1PR04MB1529; BCL:0; PCL:0; RULEID:; SRVR:HE1PR04MB1529; X-Forefront-PRVS: 07943272E1 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(366004)(376002)(39860400002)(136003)(346002)(396003)(189003)(199004)(2906002)(6506007)(386003)(5009440100003)(6486002)(51416003)(6512007)(52116002)(486006)(2616005)(68736007)(956004)(53936002)(476003)(446003)(11346002)(305945005)(26005)(7736002)(55236004)(76176011)(186003)(16526019)(50226002)(478600001)(47776003)(1076002)(3846002)(6116002)(48376002)(105586002)(106356001)(25786009)(14444005)(50466002)(5660300001)(36756003)(72206003)(66066001)(316002)(97736004)(8936002)(81166006)(4326008)(8676002)(86362001)(6636002)(6666003)(54906003)(81156014)(16586007)(110426005); DIR:OUT; SFP:1101; SCL:1; SRVR:HE1PR04MB1529; H:Tophie.ap.freescale.net; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: nxp.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; HE1PR04MB1529; 23:f5ozKjpJcc58cWMGBQ6mCKIpBOnXl4ty4+QjssWRg?= ISIG9JiITej9jMuZ65baY+R7LmQbMa3IlTqVcvCHMzthxOe65e4AUQfyMWDmmQQqYuZb5dY6cVSssw6xWFP+/WmPHKQHeZ0yeY4CTu1a+AAdoLX9ER75RJt1mRKzEYEQpzhGo+sk5lzj+i8G6kQP9zIe/msH9XdJijF22QdKQpvw7ab9QRKwXiZ1AuADs2PzxTjCefO831gpClTwcFePCZ6TyQsXr0Rn9F69vGJMF2e2Wql6OX7TGz6d0UuLiuOyrUhBfaPxGuXzFOqfGpkop6TvdJibF9jg1ZtRZPIZSsIf3n8c9ZY5JtnGNZz9hu0FavaOkaw2QxRKnd5OQGcScydhWx1keFD5EiKTZbFqxLwvbTP2h8pl6JZ48nk8fYLdoNSp+DeGuYbw0jgX6C2ToRhAG2SrDpK+r1DeNwgcWeM7+3KQwGsOBI+wydZoHK0DKF0jFGBnBGMZ+UqwcZo0jh2PtM4M+NuSPpyk6zQRM/PsPokBf+IGA25YD7QwO/D23dZSbeEokv4phtXlLAhYT/P6BeteUQsmWsrNxoAnxbExETDtwGIFO6TS41BFknr7TGAFjc0tnMrWSXHGg5mV/Dt9Jp8B3/LlAcjvySLbOGC/Ss29X5xI3oORoW05Vumc9eJtUPehAF6NcPa1Y+h3Bd1HYBTBdE3QR1FaVTFv2AH/ZgN1XwR9Ly7nqWJePb7zJTCIWgu+Vx+TAVKFApOE7vFamjMQmiRFpxWBxnPGWNEAsMz8SEzEdzH1L8Ci6Q181ODasJoJ6uPyxwahHBSCWZ5E+YdfNCeVwddQIaP+N25iHfcxlYUlv57YHj81GxBFM6USs2OGQU0YtbNcsFDvVQBGr8xdYNxeS+68bpDD3AOdpDYLEdNzkic2SLG9SwXNa1n6Zz4Je9DztXJfTW9wkVFW34/2E2Tnzop2JK9L8bNgCngcp7AE0cqk0VGY/qOQR/JfpmbyGI60jwiBkmgShM90U7EBqE1VIz4J68rOEUAbi6fNNVZrssDyGABCJC526uZfnho+a14b6D3w5Ho88WS82N+fGt11WlmmnR+3SqhoMiH8mX1AlNdQZv2VMfVKGDfiRHD2uhRu7MdU5XMgDELrmAeZ/QeRqzoWgpD3m7T4fAB3ImiIZpkxOwCXoaZ38lnxcFeXCOS85w2MG0D6hsSDpo1x/FHrDkZzNPtolq3RzcX0MYzifyCzwl7GONojmb54I3L8TefRYidCcpN5COwLe0YAZCYjiLE39DJCHL5wYvUWqsqCvotovqu6fwe/smKsvvMo4RTyIGr5E3PtWUd X-Microsoft-Antispam-Message-Info: Gx1Lq3c0d22VWSHXG5L1i9B588WEJpzIc+lg+rPfauZ/XcbjQ2SVZUstn11/vgdWZT0IMQOrSoR9hcpigC+PhzvnVQtZ4uxOlOxX5vTb9EX4KRPgtucmjBhBDSzFljvCwFnT5logmhLeL+055cqvrB4mMLu7UP/F351Y0VTOFKg/erDW/6mk96ETe4QPSlpMHXkOaoy/5W0YTsXuD805p0CRHxYUdVDemSe5EDHrxkOBkmqda9KFQy58Zzzw7ulmSY3WVxMHXFQDyuDE7bTVKIBGifWTzNF2YQvvk2/E6ccCMXUGqOHFcDz1voWf2JgnI+RZUG51kxFTWPDiboQSJHIvhJ9qRA03Z2SSoG2J0OM= X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 6:nXh8fOqZ4e4IgCq8P6riv+kq34bjh66bZHWTENM8Oa0Il8rMTBayt3U/z9Hp8dMVQa2AQIgs/EnBg+lvkaYC2fkN8P7PsjZ6L8Z1eAOmkMgYGe/fopKGdvIdZwLXgC5GlGbOusTz2T/YzmuPgwYI3+vAYpvRrgBAZVIX5oA9XMhjdUN3YMrwlZqLxIVmjPSnT9fwHTPlGBY6OIKgs81qRICViA77KCtqRsPif0enRlWKjC5zM64nTpS+DxKtio6GvDF1JzYLxiao0xUR8/iwbJDSUr+btc4N9/krPtdoirE5UwsBDTUK9JdIZUiJbnRTahsBQK6Nrn1yIsbJ2GsM9xV3FPx0jRS69PbmN7Gzq7dfetCyf8YqgFPvDtUiNbucO6mItv8Wu/RBgqq8ePyE7fFMuIi24Q+vINQcDilMN94ii2rOxSB3gJMu8IpiwajHJbKc/R5E+JqR3p2D2qbc5w==; 5:PjGJQyXejwYtnn+7fjbiQQeIbTpKF+fRj0Vm57CnuAFcj62h20fB6DaItp5d+LLYFmPwL0PQTktDCBMHzOau0utRhr0a/P8O7vIXC82SWWGQCCkwuEfePOIVHJXnAwH4d7B3osX1D72KtZ+yk4pbVyhAYUA+C2hSDamCDmqcHpE=; 7:6nRZGplEZB3Zqa3ClxaxevwUAgIAY5Ft7tO2xu2n1FoAWyTHPD6qnga1J+L4s0o3l33d0UjTnVaD263Cq5AE7fA5FGz691oM7U2Sfhh4gwYaOwh7LySD7Ul5iwjzL8l8Vs1I5WES9ou8O9zh7doJLsLzOM1InfqFUYUyqetqECwwwrJ8oDSjiSPix2/9cBKwMgo6EftvoXy+nslJZtEG+BL50dfVy7gzXxrCwB2hfsgkatECIt4JIDYXCgwmFsiN SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 13 Sep 2018 06:09:29.7104 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 651f06fa-59c6-4956-eb69-08d6193f7824 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-Transport-CrossTenantHeadersStamped: HE1PR04MB1529 Subject: [dpdk-dev] [PATCH 05/10] crypto/caam_jr: add queue config functions 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" From: Hemant Agrawal Signed-off-by: Gagandeep Singh Signed-off-by: Hemant Agrawal --- drivers/crypto/caam_jr/caam_jr.c | 64 ++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+) diff --git a/drivers/crypto/caam_jr/caam_jr.c b/drivers/crypto/caam_jr/caam_jr.c index 43fe5233b..f05e966b0 100644 --- a/drivers/crypto/caam_jr/caam_jr.c +++ b/drivers/crypto/caam_jr/caam_jr.c @@ -104,6 +104,67 @@ static void hw_flush_job_ring(struct sec_job_ring_t *job_ring, } } +/* Release queue pair */ +static int +caam_jr_queue_pair_release(struct rte_cryptodev *dev, + uint16_t qp_id) +{ + struct sec_job_ring_t *internals; + struct caam_jr_qp *qp = NULL; + + PMD_INIT_FUNC_TRACE(); + + CAAM_JR_DEBUG("dev =%p, queue =%d", dev, qp_id); + + internals = dev->data->dev_private; + if (qp_id >= internals->max_nb_queue_pairs) { + CAAM_JR_ERR("Max supported qpid %d", + internals->max_nb_queue_pairs); + return -EINVAL; + } + + qp = &internals->qps[qp_id]; + qp->ring = NULL; + dev->data->queue_pairs[qp_id] = NULL; + + return 0; +} + +/* Setup a queue pair */ +static int +caam_jr_queue_pair_setup( + struct rte_cryptodev *dev, uint16_t qp_id, + __rte_unused const struct rte_cryptodev_qp_conf *qp_conf, + __rte_unused int socket_id, + __rte_unused struct rte_mempool *session_pool) +{ + struct sec_job_ring_t *internals; + struct caam_jr_qp *qp = NULL; + + CAAM_JR_DEBUG("dev =%p, queue =%d, conf =%p", dev, qp_id, qp_conf); + + internals = dev->data->dev_private; + if (qp_id >= internals->max_nb_queue_pairs) { + CAAM_JR_ERR("Max supported qpid %d", + internals->max_nb_queue_pairs); + return -EINVAL; + } + + qp = &internals->qps[qp_id]; + qp->ring = internals; + dev->data->queue_pairs[qp_id] = qp; + + return 0; +} + +/* Return the number of allocated queue pairs */ +static uint32_t +caam_jr_queue_pair_count(struct rte_cryptodev *dev) +{ + PMD_INIT_FUNC_TRACE(); + + return dev->data->nb_queue_pairs; +} static int caam_jr_dev_configure(struct rte_cryptodev *dev, @@ -186,6 +247,9 @@ static struct rte_cryptodev_ops caam_jr_ops = { .dev_stop = caam_jr_dev_stop, .dev_close = caam_jr_dev_close, .dev_infos_get = caam_jr_dev_infos_get, + .queue_pair_setup = caam_jr_queue_pair_setup, + .queue_pair_release = caam_jr_queue_pair_release, + .queue_pair_count = caam_jr_queue_pair_count, }; From patchwork Thu Sep 13 06:08:42 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Gagandeep Singh X-Patchwork-Id: 44642 X-Patchwork-Delegate: gakhil@marvell.com Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 80F845B36; Thu, 13 Sep 2018 08:09:44 +0200 (CEST) Received: from EUR04-DB3-obe.outbound.protection.outlook.com (mail-eopbgr60063.outbound.protection.outlook.com [40.107.6.63]) by dpdk.org (Postfix) with ESMTP id 43A505681 for ; Thu, 13 Sep 2018 08:09:34 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=WktA+qFwfWsz/LvMvcJ7CaFGRpv5X0Y9sKoulN5DWiY=; b=Rz4m22AvgVVS2kzIBii1I+exl1czo1Mr841RCo7QKNn3ctmQV9N/Rh1dwi63qS/7JuYOAkVRActMNyiD200yn9vbTIq5NrKvZMdrdV88CC/CFK+YXhoK60ySbfRLJ75B5y6NE+As/EXdJI1/YZH72l3NCUzsf4hKe8TNOZv+ed0= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=G.Singh@nxp.com; Received: from Tophie.ap.freescale.net (14.142.187.166) by HE1PR04MB1529.eurprd04.prod.outlook.com (2a01:111:e400:59a8::19) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1143.15; Thu, 13 Sep 2018 06:09:31 +0000 From: Gagandeep Singh To: dev@dpdk.org, akhil.goyal@nxp.com Cc: Hemant Agrawal , Gagandeep Singh Date: Thu, 13 Sep 2018 11:38:42 +0530 Message-Id: <20180913060846.29930-7-g.singh@nxp.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20180913060846.29930-1-g.singh@nxp.com> References: <20180913060846.29930-1-g.singh@nxp.com> MIME-Version: 1.0 X-Originating-IP: [14.142.187.166] X-ClientProxiedBy: BM1PR01CA0095.INDPRD01.PROD.OUTLOOK.COM (2603:1096:b00::11) To HE1PR04MB1529.eurprd04.prod.outlook.com (2a01:111:e400:59a8::19) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 172b737e-a3b6-4dfb-6c80-08d6193f7926 X-MS-Office365-Filtering-HT: Tenant X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989137)(4534165)(7168020)(4627221)(201703031133081)(201702281549075)(8990107)(5600074)(711020)(4618075)(2017052603328)(7153060)(7193020); SRVR:HE1PR04MB1529; X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 3:cIyvDG+FYo7V0T1DmaIwynITcsf28n7IBsCOkyQew2neKwjh2HEtroRSX6y4NvhYAcyw54B3WPeyDF24wDo+Yeb4dZ4MMyLTjq83UiI5HptbS0t3Pv3UruiHVTkvV+aWpyLKHlSpKf8/a17B1tA3ymMsfSf3gk2OyiFhNQlaI/cBB8t6vIVgpfU0KP4ahZsbjezItD3DQB+9cMJFIGDE5qrfce+QVfW7br+8f7jc2E4mVeiGGDy/vYmkdJStuKOZ; 25:bct4H9frblXtkc0B8ZcPFVz7Cln+jxFQ8CokTsmmWwZjNaftPyXARjVNly9m364OYYY0x/dfn7tG2mZbfaUDYwLVtMMIVGJjLg8x/r2Fpaq2uUoGtkvgJOTedcgLHpmPGEf98Jkog+Nv+0YrtfJ3fAXvoaYO78eD8XUr61PEasUoRzUHCKw/9CWCR9MrLHtQTL7HNLaZG6+QrdrIAH1HekKdl/tXmYBu7gnUq84puwW9shjpblOr/qRklprjWriOgJOh5p3UTOVTBmW4yeME/rVujCriLJzUqqdX9MFeo81qctF1wIpTd0WgVC5Fs0Y/Ahojap/DuL3ku/CPvzNBxQ==; 31:MxYCR+b2Os7lt9hEyZv6EVYRZRUGwj9A88kldM/9plzYHU1EYSnN9aQFYxOshcg3qh1d2CDi6rHo1O42OPyfQhmi2bieVTOv5PmvqXdKmpW0AH/U/WKcjNeRd/n9Y+j5DyQ5NPDObN/R/ODhVBDLtkZwrM3i7Nf6Hz4KZ7BU6a12RJ5J5w/N2x2IL0weTUHKcGb5OQiIJPtWFxdMFcQWYEO6jtSKRPWS3zyg6Y4olxc= X-MS-TrafficTypeDiagnostic: HE1PR04MB1529: X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 20:ZxkKFqRsUACo0drggcdCXFbL1e3iq3w+rWZubmkhAH3nFCaQh7pWXgxC6srGJbFwkG8A0nAGQmNciKxay6X2sa21N/cRBgzRcLjw87khg5Sb3wVP0P6TE7v+MnD0mQRC+JSrj4ILJroLAZyu6pqjInpOUgEOdBKQcrDki5Zbdi/rwnSMmjA6H6f1fo+c11CUODAblce8cp+LDrK4rrhryBockKmvBksrY8e3NBcVkhDtZiNaq4XDrUHx1SE9PVAU8GWWxP/StIYCWJd9Qw0P56ti6H7Id+KKlYeQP/RVVLiUo5MXs/eCCO/WJOaw504wPnfSeEgr8w/zwRNabEgtxYGVlxeRvFz6A2pAjQmqSkwxq2pM+kuX4MK0IV1HZ5IAtZ1TS2sJQIrH5gDAoF+gqkA78vZWXNf5ZI1OFqXnoQUew9R+MSwbsX5kUbHo6XnxjA2BKE1NswSDhB+icoPqdkKUOS57bcBqL2J84CynMN3NfSpnDHgLy+00rsaljp1N; 4:ssLtTcHZKKjaq44pkJhuUsBPsTr+mnrqCocXgUjXK0fKMz37+bkLP47MVtbT4+ai6eSD6JA+olojYveUdGus6tELt+4Jf4YmTJEcGZKE2pmA8JFwfwkeSneuIP77ByUe9UOLKI9UMqO0ymjDuru2aza4ff8bG4eLN5TuRPhHOpKGBmHUU1JL7BSxTDbmnPTeTigHeaAoMROBDzjj9LurFkGz1g4GHSRamouZtj5+CWylzHKuI+jgQjBKS8GrOb0GBhgSX1znAg5xfmewALKLBbHu6JeOMMr1jO2ar4K9vl2jNS20XTodkS+9wbq0N2YR X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(185117386973197); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(5005006)(8121501046)(823301075)(3231311)(944501410)(52105095)(3002001)(93006095)(93001095)(10201501046)(6055026)(149027)(150027)(6041310)(20161123558120)(20161123562045)(20161123560045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123564045)(201708071742011)(7699050); SRVR:HE1PR04MB1529; BCL:0; PCL:0; RULEID:; SRVR:HE1PR04MB1529; X-Forefront-PRVS: 07943272E1 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(366004)(376002)(39860400002)(136003)(346002)(396003)(189003)(199004)(2906002)(6506007)(386003)(5009440100003)(6486002)(51416003)(6512007)(52116002)(486006)(2616005)(68736007)(956004)(53936002)(476003)(446003)(11346002)(305945005)(26005)(7736002)(55236004)(76176011)(186003)(16526019)(50226002)(478600001)(47776003)(1076002)(3846002)(6116002)(48376002)(105586002)(106356001)(25786009)(50466002)(5660300001)(36756003)(72206003)(66066001)(316002)(97736004)(8936002)(81166006)(4326008)(8676002)(86362001)(6636002)(6666003)(575784001)(54906003)(81156014)(16586007)(110426005); DIR:OUT; SFP:1101; SCL:1; SRVR:HE1PR04MB1529; H:Tophie.ap.freescale.net; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: nxp.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; HE1PR04MB1529; 23:0pZXhIIXwU8fOjWF7uyxs5I/OwcnEqb0Ei1imNht1?= PP50TeaA34oywSXQQbx34Q7Q8qxEP4n7nHskZ79BmvBSfWXRJbsFeBVodUK/JyZnaW7IOC3dV+qV5GaGnI1d4MzAJ1u9z1XTzHValODb2/oCWmDLih1F8swBtoJbUGvLpf4z4rD3dbWBMRjU0Ta5YygPtrnRurdfy1bLrGHRwBMu73nsgqOAHfkmXj7LExyyVJeAW9yitUg2eOLz37MzBDvmypOqXaQjRIay0DQETue+D7lvUdLY1A/wqZ3/86IwXS+WGSFT6+jxPA9c4p0MXN56ZpFTev4WQtPYt7RQr583HoQ1niYQ2XwAJb5Ct+S/CeIBFA4I+TNEI3GNzVQeA4WcUspuvXsTXbiYzAwtKBM8L3Xl8GHtI8Ve7KnNGEZedfmx6msE67x4fY1b/UrQ63aMtZDDk2yKfdR33DiAZnIvfxygrWqMKaLb5qjRXr6kYVZ19bnPAeARRzevQuuDpCFO1ceuO9UAakGAwT1WjsCD26b7ttbejIR76oPiZlo3swlFvFnJoUqyQN8dXVHkdlDgXzMH9wUurThjRJ2FSIJ9OzpehFdMz/hVDrjOxJ5xGc3ffW9auBDqJSdDJOv83oUaZc/e6Lq6OLu7Xb11gMrYCtM0fdRbXNco2dydKFl6KXcWNrH5ZjZ86gPYXtDzayKsBQhD3pLcaJejNAvt9GYVo3UpCNwUakWpvNgc04DV0p3DbvEK2VyoLo3ZwId801286r50TDXttIx5jiYPpcW3EWY1v7MRiYuJx2ZJ4pYPfwJhu2y+ht+0F0B6gbaAjKqh/bLArJFLgBG+hWYCLl7znEdCVKEGqzaes3uxFlo//ZXgMle5LgoDYhTv1XDt/AbiABcLd1tNw7ir7vwmCc6cVo0ShvrkPznzArbuka7EDEHGG7kvBjrrzXCqDr+vBww+Pe6f2hzzggirfLUrUJx3FfLD0Ow4QEguCKkQoqdRhemBgtPGpNzCP2h9l18Hd6AKXdOABSqo4nROL+Z4+izQiBy1Yai8WUPJX9+0iHt8j3ei9RmJY4kKmBQD9/JAF4MUe7b67xFfSQVDOq+Nv6eFCy5+g3L2h+HZnhj+DHA5jOghN0FOnqYB1/ZCSnOQ20KwAyRJlK6ANfWoH6xu497ri/YeTH59nch74tyJ5V/GWpbBRz/c36XV+4LJsNAP+30Fnp8zUnP+fn79txmCEC2vkiZUc7Cy3bDVSrmuhHgS9bSlq8DEPfx5FFBLC6XY6G9v8SscJB9TQFdXXgkDD+Xmtx0WtpYB15H99vxpDKUDx/X7IPbu2aryxKxf745c4TI X-Microsoft-Antispam-Message-Info: E7xqhasS6sNxBMkeCzV+TkAW+GYC4FPcmsceESLGnhGr2FVHzpOTQgGiHncCJB0/GZTzTcOa0wmTJyYLJiOrvXhDJ42W6YztpMwcufHfwB6KYOJ97atuAul2kk5gg/SdFA1b5Oe3S4l+LYpzS6vqJbfmA8s417sH59+efAInsG2JiAW1qkt64PEt1uQHgeEl45jjPXU7m/xiF0msrX5qrpGmf5fRNyEbJSsiP/krOzfbWRIX8jiliQeNkchlbAzwBsBug6GQx80FIfcxKEXNKdAnbH4BniTsBLCryvaQL61G8eTJ4XcFhVjpHNcFmD0WPTlBsRBKgAmMWDeENViTNRuvL1C2/FmgG0WuieFwK4U= X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 6:5aezioztY4wlgjStwnnRhaRzcBV01Q6p4LclPjGl7k7EqqmglP6Dnd4yANrYJhstgCcGmFD0BQbnIYi1r4mgFHkScMHXzQIULss4kF0FkgTUfY7fQJ9Wl82xDS8HlgIdhUruTYYm9sipK8Sv9n8GODUstftdLfifuS38+KeU7bTmUsYM6cHC+HUOkDd42Mupu84dEP3Z2PXrDlqSRc0xvH4TKhnbCa2jA6rkxviFiTM98KVfpFL4uOJ37g4GRRkYNXZCQO9nc8M0pZqZyMakcz/fSj8sgSpzMe+bfuKicziVR5Pev0tDd/D0+sdm2GOyBsuIUuh4JiTWLpQ8CtOnRnCKYAjUxUsFK+3i2UMv5XYEa+ymtSeuUN+qihXxTRKcKf7MfjZSKrfPWiUSKsBt/UvqpqM01ne/Ww511IcrNnjG1Enhr1p0/M+MKBwwb1LVANa9Hsaj+/vdF8FhiN1Eyw==; 5:wXBl/mvFM/ex3G1Vp/sxUf9jgLTCBJTDgFi0uwqcM+3Mf+K0EcXzgV/qEnKE6VG8Nj7Slt+vIjz/crr4MBIRvWa78YyH5xQjIKZPCc/qsdQTS4Up0G+ZlAvoWtbVO97jH37XS7gOeyvnzp/lEg+eke2ylYVmBSAyA6KGVkaIlGE=; 7:lmAwJ2tpdIhnO9b78x9KKXZjOy19+dt+ETKIsd1k645yWat24Bip3CwW6cXTaMJbTIyaB560M3gCk8wKOdF11s1wuKUryzricWHPmbXowiuf/749eAquRCF6skNg1thI+tAFSzOLjOXVTCkzx/5etCMGRw3M5f4jICiQjC4Umb8VMY3eE8GuCS3xLnPNZamyygEB6ThkMoJ6n36T0pw8Hr1jpT1FxYlFKSEd5CAIo09tG/m/EdPwRPHCKqfaLPLd SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 13 Sep 2018 06:09:31.3979 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 172b737e-a3b6-4dfb-6c80-08d6193f7926 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-Transport-CrossTenantHeadersStamped: HE1PR04MB1529 Subject: [dpdk-dev] [PATCH 06/10] crypto/caam_jr: add basic session config routines 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" From: Hemant Agrawal The current support is limited to crypto only. Signed-off-by: Gagandeep Singh Signed-off-by: Hemant Agrawal --- drivers/crypto/caam_jr/caam_jr.c | 124 +++++++++++++++++++++++++++++++ 1 file changed, 124 insertions(+) diff --git a/drivers/crypto/caam_jr/caam_jr.c b/drivers/crypto/caam_jr/caam_jr.c index f05e966b0..a0eee3b85 100644 --- a/drivers/crypto/caam_jr/caam_jr.c +++ b/drivers/crypto/caam_jr/caam_jr.c @@ -20,6 +20,7 @@ /* RTA header files */ #include +#include #include #include #include @@ -166,6 +167,126 @@ caam_jr_queue_pair_count(struct rte_cryptodev *dev) return dev->data->nb_queue_pairs; } +/* Returns the size of the aesni gcm session structure */ +static unsigned int +caam_jr_sym_session_get_size(struct rte_cryptodev *dev __rte_unused) +{ + PMD_INIT_FUNC_TRACE(); + + return sizeof(struct caam_jr_session); +} + +static int +caam_jr_cipher_init(struct rte_cryptodev *dev __rte_unused, + struct rte_crypto_sym_xform *xform, + struct caam_jr_session *session) +{ + session->cipher_alg = xform->cipher.algo; + session->iv.length = xform->cipher.iv.length; + session->iv.offset = xform->cipher.iv.offset; + session->cipher_key.data = rte_zmalloc(NULL, xform->cipher.key.length, + RTE_CACHE_LINE_SIZE); + if (session->cipher_key.data == NULL && xform->cipher.key.length > 0) { + CAAM_JR_ERR("No Memory for cipher key\n"); + return -ENOMEM; + } + session->cipher_key.length = xform->cipher.key.length; + + memcpy(session->cipher_key.data, xform->cipher.key.data, + xform->cipher.key.length); + session->dir = (xform->cipher.op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) ? + DIR_ENC : DIR_DEC; + + return 0; +} + + +static int +caam_jr_set_session_parameters(struct rte_cryptodev *dev, + struct rte_crypto_sym_xform *xform, void *sess) +{ + struct sec_job_ring_t *internals = dev->data->dev_private; + struct caam_jr_session *session = sess; + + PMD_INIT_FUNC_TRACE(); + + if (unlikely(sess == NULL)) { + CAAM_JR_ERR("invalid session struct"); + return -EINVAL; + } + + /* Default IV length = 0 */ + session->iv.length = 0; + + /* Cipher Only */ + if (xform->type == RTE_CRYPTO_SYM_XFORM_CIPHER && xform->next == NULL) { + session->auth_alg = RTE_CRYPTO_AUTH_NULL; + caam_jr_cipher_init(dev, xform, session); + + } else { + CAAM_JR_ERR("Invalid crypto type"); + return -EINVAL; + } + session->ctx_pool = internals->ctx_pool; + + return 0; +} + +static int +caam_jr_sym_session_configure(struct rte_cryptodev *dev, + struct rte_crypto_sym_xform *xform, + struct rte_cryptodev_sym_session *sess, + struct rte_mempool *mempool) +{ + void *sess_private_data; + int ret; + + PMD_INIT_FUNC_TRACE(); + + if (rte_mempool_get(mempool, &sess_private_data)) { + CAAM_JR_ERR("Couldn't get object from session mempool"); + return -ENOMEM; + } + + memset(sess_private_data, 0, sizeof(struct caam_jr_session)); + + ret = caam_jr_set_session_parameters(dev, xform, sess_private_data); + if (ret != 0) { + CAAM_JR_ERR("failed to configure session parameters"); + + /* Return session to mempool */ + rte_mempool_put(mempool, sess_private_data); + return ret; + } + + set_sym_session_private_data(sess, dev->driver_id, sess_private_data); + + + return 0; +} + +/* Clear the memory of session so it doesn't leave key material behind */ +static void +caam_jr_sym_session_clear(struct rte_cryptodev *dev, + struct rte_cryptodev_sym_session *sess) +{ + uint8_t index = dev->driver_id; + void *sess_priv = get_sym_session_private_data(sess, index); + struct caam_jr_session *s = (struct caam_jr_session *)sess_priv; + + PMD_INIT_FUNC_TRACE(); + + if (sess_priv) { + struct rte_mempool *sess_mp = rte_mempool_from_obj(sess_priv); + + rte_free(s->cipher_key.data); + rte_free(s->auth_key.data); + memset(s, 0, sizeof(struct caam_jr_session)); + set_sym_session_private_data(sess, index, NULL); + rte_mempool_put(sess_mp, sess_priv); + } +} + static int caam_jr_dev_configure(struct rte_cryptodev *dev, struct rte_cryptodev_config *config __rte_unused) @@ -250,6 +371,9 @@ static struct rte_cryptodev_ops caam_jr_ops = { .queue_pair_setup = caam_jr_queue_pair_setup, .queue_pair_release = caam_jr_queue_pair_release, .queue_pair_count = caam_jr_queue_pair_count, + .sym_session_get_size = caam_jr_sym_session_get_size, + .sym_session_configure = caam_jr_sym_session_configure, + .sym_session_clear = caam_jr_sym_session_clear }; From patchwork Thu Sep 13 06:08:43 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Gagandeep Singh X-Patchwork-Id: 44643 X-Patchwork-Delegate: gakhil@marvell.com Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id DB8E25F0D; Thu, 13 Sep 2018 08:09:45 +0200 (CEST) Received: from EUR02-VE1-obe.outbound.protection.outlook.com (mail-eopbgr20055.outbound.protection.outlook.com [40.107.2.55]) by dpdk.org (Postfix) with ESMTP id 9C2DF58CB for ; Thu, 13 Sep 2018 08:09:36 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=k7Om6u8bqruK5cnR0DmuPlVVgK61JauyX5pWDXl/HMk=; b=V1UV1tTy33JJPpXiPm3GiuGNfqL1S1bJM7q/Et3+9K/YRIWFYCdr+C2rKxTSG8+9YPly8UtFyrjWvAcMVXWkmVfinNOEA6fY+p80ktfb+lvq1m7JuU17tixzA0gUma/NwW6wnAXZP4jgtZMAzLevPdS7ApePskKJiRtHlcXKuK0= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=G.Singh@nxp.com; Received: from Tophie.ap.freescale.net (14.142.187.166) by HE1PR04MB1529.eurprd04.prod.outlook.com (2a01:111:e400:59a8::19) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1143.15; Thu, 13 Sep 2018 06:09:33 +0000 From: Gagandeep Singh To: dev@dpdk.org, akhil.goyal@nxp.com Cc: Hemant Agrawal , Gagandeep Singh Date: Thu, 13 Sep 2018 11:38:43 +0530 Message-Id: <20180913060846.29930-8-g.singh@nxp.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20180913060846.29930-1-g.singh@nxp.com> References: <20180913060846.29930-1-g.singh@nxp.com> MIME-Version: 1.0 X-Originating-IP: [14.142.187.166] X-ClientProxiedBy: BM1PR01CA0095.INDPRD01.PROD.OUTLOOK.COM (2603:1096:b00::11) To HE1PR04MB1529.eurprd04.prod.outlook.com (2a01:111:e400:59a8::19) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 545f8fd4-ee1f-4cc8-291a-08d6193f7a23 X-MS-Office365-Filtering-HT: Tenant X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989137)(4534165)(7168020)(4627221)(201703031133081)(201702281549075)(8990107)(5600074)(711020)(4618075)(2017052603328)(7153060)(7193020); SRVR:HE1PR04MB1529; X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 3:/eFp3CqbUAHgaI/krfcQXruhv41jd0EFw8gelHBpRsoCM+5Pkr3UsmFgnClF7I7DBrlGECh+mUPWVG/hf/kcoZwo7+f0ewerMm652SW17+L+WapLtEHxC5/p+Q/x1d59nSgutj/pxplRQJBEDFLZER+pWll0Vyvb3JBC3EtelwC/Qt5DBF5UpejeM5KTKlh6B4+nU7w8Tk2FaMQiYrdjo+OCNeY5iJorVMpf39oGJvABKuD4RIyYUX8LuyWBBmeM; 25:CndY17vwIoIbYq/3UdFjpwA5BZ7MPV6D8WKog00oiocz0zStXKd3Yi509G0BzDeajaICQfEkzu7SlrsWDjnDnZtWHMrYeS6Md8s6gotDWNrgRS0757D0JKc9l3SSfQyl2IOpBlUbIDm70TK1AWNsPpbWHNLfyhavf9NQvQe2lmRvUN0h3XKHFmLgP+98gwey4yjrvbKCxrvLXmnshpFMiTut9Fg/YwOywM9LYmQYdpqFK3f6A88TrwUs4NtNwnmGplvVGCsdOpq/jJ+vs0VN4eC3/MACO6o9+WTf7VSXQ4zvvcoXJF0B55Z2BgpK++GiVNntuKNC0Rlj0cUvd+b4Qg==; 31:ScFSKbVz4k3Dx3zMtxWjrvvsN9vP0TJL1SN6ZWRCj7TL8RrSmVDI3FMKGoelQLqlxa3Dk951aD2cE5D93878WzAAdz4iTGVwoFRIIQZb22LS4JP7di4vIfa0o6ubvQEt3QoO0PNTnUG3LFUkRbM2YQ9SuAOJZySsvnuei1N61CgPEqaefJjbcKpsT84MP/j8Q/coVSA5TxamrsQcBiTETjFuOwlpZukXZTBk6kcVgCE= X-MS-TrafficTypeDiagnostic: HE1PR04MB1529: X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 20:+ADgYIoIEmf7gvqJEwk4CzjXHHz1QgS+T9yqHJ2j8uSjlJT/7w2AxkxO6oHOcln1P00VBae7BXjdBG1RVzJV/aAGtkgdKsjRNe/RBqqtXfg9GRaWT71LyNt8qCK+UfWIsipZ5K/o2dHlrCDv2xd46oUsTyl/uR8MUI8vV/XrPMQmse5NnXBY6v7Cm58GnsnNPr1h0suzHE4/cFMWamCp5iafVQA+S+DtbxILfVcSNe9od52ArHzt5yLVV5sZsgpO3tHzl/jbuSRpw0r7RCiNsN44KottTzKVB8ln/t+jX107iY+llzKJNbkLvhEgDYMZWOreJ9kLXMhQHu59Vh6RVLPR6M4IcnB9ywLCgItLjCWiee3J3RuCYksT6+vIHhJ2aSArO9wd+ZJtOKlPoUe9hbcf536a0N3W35uvygy4qpn2Yeh5cKh8KhLR/IYHbAo0/6KJi1mIVAglhmkokIqsVjFwGSo60o/Kat6GjkbpZtRr8fwObiIxRovOztnr8j6E; 4:WHUMf6GTjfaIBOBC8nj9aVCklXUMWIHNBcvMIN0G1FicZMZm0gGePXJDBhmHhuZe21//P92KQmEbk93pam9Amhfoyeer8TBC2Ru0kVR68OkIbKAtzZWZb0UlhW67Ci8NCq6POCllif/ibqaVmUZa8f0U85NODDQ6meAH3WKOdXOPpatuU9OUgJz8iXHg3V3OulRdIHdztRj92kOMxg05nd1Njg6VSGcEC/Y+hBDfUG4RgC8Dr/RDYU4XVfbAzDHZWRlnpasGYp7q4Epcz2CBfxetx+G9BICrKnZvA9kdU/+3sWCmbZAX9nsC8IUSL4er X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(185117386973197); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(5005006)(8121501046)(823301075)(3231311)(944501410)(52105095)(3002001)(93006095)(93001095)(10201501046)(6055026)(149027)(150027)(6041310)(20161123558120)(20161123562045)(20161123560045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123564045)(201708071742011)(7699050); SRVR:HE1PR04MB1529; BCL:0; PCL:0; RULEID:; SRVR:HE1PR04MB1529; X-Forefront-PRVS: 07943272E1 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(366004)(376002)(39860400002)(136003)(346002)(396003)(189003)(199004)(2906002)(6506007)(386003)(5009440100003)(6486002)(51416003)(6512007)(52116002)(486006)(2616005)(68736007)(956004)(53936002)(476003)(446003)(11346002)(305945005)(26005)(7736002)(55236004)(76176011)(186003)(16526019)(50226002)(478600001)(47776003)(1076002)(3846002)(6116002)(48376002)(105586002)(106356001)(25786009)(14444005)(50466002)(5660300001)(36756003)(72206003)(66066001)(316002)(97736004)(8936002)(81166006)(4326008)(8676002)(86362001)(6636002)(6666003)(575784001)(54906003)(81156014)(16586007)(110426005)(134034003); DIR:OUT; SFP:1101; SCL:1; SRVR:HE1PR04MB1529; H:Tophie.ap.freescale.net; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: nxp.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; HE1PR04MB1529; 23:B6oMbLuTklqNwhz6le97Zp1+sscPIHMunQ4ttblVy?= IYn+98OF4ypdma2xOmCnle7FCmhFE0uCRqAUsQknhsHcZNVw2+l0r5srNCF/lAXAklCSzcRXgn4MxkT2Z7ZUDuJOci3dYJkH3mSaht7pbEA/DYIfPckeHrPhfjPkBHuh35luLn1WrXghybOO2jMZUMswmBBhCZPOi/ANfxum/mXVjeaedry1WA6/GRuSIGLkAIVSA+IbWD+qNs5mr+YMhQuKycFRRC8i6B8mtsfo8tW3hc/rqzfNDDAAEwqERKObRk/Y9+oM3gpZhIaYyZEN6kYWNC9qBPNb3ouJFkQuTTpAalfQfIxuz0lO8Z0Y+5a/XdO2FB85mJ1uXJy73E2HAd4Q0x9aJuDSqBCOhYGLthT3Wz+GM97N1mMPuRXMiGyMxc6IFgin2FtmaqvbiIzvOobV2UalsQoI3KVCPnyWA0WSdIhD4tLhlNUJZHr7iBO+mKjpYSRqGrrNqLEy3bQt81m9kMDB9H+aZBLai+0IG7nAwOoN2vwyqoj8gTbTZXno5cT8pH9gfRms6tY7hT9NeisaSiHLuH4g2lqgXEArlqO6qBRCtOEqkmwx82lAYtZRdXp8bPDPDx/MUBsmV3RcV84MtJDTzcvsyMGsR6n+uije8jd/Utqu9WCIZRX/VJUaiq792TnDdA2i5r0dk9ZB2r4+EZnr+920uri0bk28DN5cpPc0pohs2xTmAh3RTp0KraIz1t9orljPKTv3cc8rMuFkKDnZmYicujfgj4KGoPZaWS1EEH0sz+jxEEVGXKbSrOyCuAsKiZXk/Pko4QcBc0u6PYXgqSC/68bK3HMVhEfgckoIhF02s+3HdZAa1N6qyL9OytInXVPX3gMfOsjg5uLx4pqjsF1y/ndgbtVuP6EFH/h8p/6TxlCHFvFI+ziYZj0NdecJp2eR0U5xB5Q/m8l89fhyEdKJ4XNCSFhXJhd1qRRWlc89t9FRWSuFjulhsNSQ5//RgE9rSulAC2ubj+wcodJ7KOuvN/QhADu7AyL+Ayd2lrQE+Zh659FXymUaAs2MG+PD20KFL3kf+WWaZDPdEGJukBMrWi1eChVZBfWEnw4/lnidjKBV88KCH+OQJ4IP/SD6UUj1/sLeLboqAlYlrirLbIeAVk6Jt3zSp3x8Ra0j1rCxn1dFcQsnpyqRKsSbe0Fm55dy0ylh+Mgb4eXWtNuxR3JuMfkvx3/VbvQP0H4j6CUCv80xaMKOOl/GHpnkP6R/7Uz9C8oQHRNOUENS7NMd1ohmC3OMhNhyRr1WU86IT4+xiGVoy+FrluAKpvdZG/4HLhQB5809mvBW2a1TUHpXKt0mscajkLIxiy4hJELKFflsxF7WAeDDpvunM8= X-Microsoft-Antispam-Message-Info: rUot0h5poEb5+CGHdUwj5g9EdwuMH9WOaWKxInB62flKaK3BI+Y/s4sf6HRrbgwXVCMDDa6XcnUYcxiBhaTkKi9Ulk1vQ+Wj4aNeUPPjmLN0nqkHNfcAGRp/4ow/A71liHTt+WnXQVQg5wsU2cr7CuiQYqMDEzzTG7rfDaLOALZ4mbD7amTUewyO8akKB4mgaDFlz/6X/pcLg1rl3MEtPcuEJojNZ03eah0K0o44c8SXtWnMmyBU1ghfY49Y+tgxY80NHRhG2smZMXkZ08Q5WP4yHTpFZD9IyRADP4w6r77zURnElFvuRIHu17gcQdTJW37qOGrGjGLduuMNK8DKwoqTj0kgrs6//XP6D63WSYo= X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 6:P8t2IL9RkWveOgCi/rQuW4DLu/OjR8itBaQq47l+vy4pUxgHiADguenp015Kgxtb5bz9e72X50f4DHIGQAdKzncOEaOfwBFx3mfTOp6u0BXc8LpI46XrK0aZFDSVlsvhRmibXLo2kU4hgspw7yKaHhg5kSB/X8W5ehSZJ9YOUO+Wt7o4qfxmtUTMWY1X+WNUhA4mqAx6nRjWsjDsqj9dz07aiRsbQT/Ask2t5I/57ow6ylEsTyaNRuGrsUG16xcN0+LLJFB4ds+FU6EB+l4gbvv6p708T7v/5Wv/OjiraDLEzv6IVjrxGxwLJSKHqDVV5DKGHdsjTAMy+R3AmMePIQ1Abv61WfXzlCkazTkPHQ0F7LVqw9WXQ3pTgqlR2kA9ykrTzehpv+YiYzncFkNirGigLayOilVSCSg+ex8Heygzk7FouIKby/v4kTzQLy3/cRlYd+N1mUTmYtUIjLhxNA==; 5:p+0o+/DyWxM8cVBpcbLM0IIJx1h0VDVJC4pUD7jDuWUuIDoCHkgps8ochiltUFoToFmcKhTd7kIG2ykQnv94bdXhnnwEBt5Dv2c0PumfD0taU9tTfJypc0DiOXaEZXUDEwiZjktA9b+GaCj1bV1AVfTWGUgp514mCsqfOeepvWY=; 7:DahASQgbH/vfhXTuB0uYdnfdNcOmBveViWD9FZTUmp8bdQwGDRpwDwx5TIkmJKsf3Ef2TAo72OwuGmBPqFHgV9kdNbKxKLupfOG5bh6Scq63ObfcpW13G9kkdrrGoVdoyXCNQY86nf7UVGJPcPKavL61GJNPY3UahvQiQHwIxXo/QcfsbhAjFkzXcf6K0In2b7kGdbpZriypCciiFExB9kS8IilmWdcwljokFvxvPa1kqWRLaoyoz2z2qK384d3h SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 13 Sep 2018 06:09:33.0543 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 545f8fd4-ee1f-4cc8-291a-08d6193f7a23 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-Transport-CrossTenantHeadersStamped: HE1PR04MB1529 Subject: [dpdk-dev] [PATCH 07/10] crypto/caam_jr: add enqueue and dequeue routines 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" From: Hemant Agrawal Signed-off-by: Gagandeep Singh Signed-off-by: Hemant Agrawal --- drivers/crypto/caam_jr/caam_jr.c | 621 +++++++++++++++++++++++++- drivers/crypto/caam_jr/caam_jr_desc.h | 289 ++++++++++++ 2 files changed, 908 insertions(+), 2 deletions(-) create mode 100644 drivers/crypto/caam_jr/caam_jr_desc.h diff --git a/drivers/crypto/caam_jr/caam_jr.c b/drivers/crypto/caam_jr/caam_jr.c index a0eee3b85..6d30c4f4d 100644 --- a/drivers/crypto/caam_jr/caam_jr.c +++ b/drivers/crypto/caam_jr/caam_jr.c @@ -25,6 +25,7 @@ #include #include #include +#include #include #define CRYPTODEV_NAME_CAAM_JR_PMD crypto_caam_jr @@ -50,6 +51,142 @@ static enum sec_driver_state_e g_driver_state = SEC_DRIVER_STATE_IDLE; static int g_job_rings_no; static int g_job_rings_max; +struct sec_outring_entry { + phys_addr_t desc; /* Pointer to completed descriptor */ + uint32_t status; /* Status for completed descriptor */ +} __rte_packed; + +/* virtual address conversin when mempool support is available for ctx */ +static inline phys_addr_t +caam_jr_vtop_ctx(struct caam_jr_op_ctx *ctx, void *vaddr) +{ + return (size_t)vaddr - ctx->vtop_offset; +} + +static inline void +caam_jr_op_ending(struct caam_jr_op_ctx *ctx) +{ + /* report op status to sym->op and then free the ctx memeory */ + rte_mempool_put(ctx->ctx_pool, (void *)ctx); +} + +static inline struct caam_jr_op_ctx * +caam_jr_alloc_ctx(struct caam_jr_session *ses) +{ + struct caam_jr_op_ctx *ctx; + int ret; + + ret = rte_mempool_get(ses->ctx_pool, (void **)(&ctx)); + if (!ctx || ret) { + CAAM_JR_DP_WARN("Alloc sec descriptor failed!"); + return NULL; + } + /* + * Clear SG memory. There are 16 SG entries of 16 Bytes each. + * one call to dcbz_64() clear 64 bytes, hence calling it 4 times + * to clear all the SG entries. caam_jr_alloc_ctx() is called for + * each packet, memset is costlier than dcbz_64(). + */ + dcbz_64(&ctx->sg[SG_CACHELINE_0]); + dcbz_64(&ctx->sg[SG_CACHELINE_1]); + dcbz_64(&ctx->sg[SG_CACHELINE_2]); + dcbz_64(&ctx->sg[SG_CACHELINE_3]); + + ctx->ctx_pool = ses->ctx_pool; + ctx->vtop_offset = (size_t) ctx - rte_mempool_virt2iova(ctx); + + return ctx; +} +static inline int is_cipher_only(struct caam_jr_session *ses) +{ + return ((ses->cipher_alg != RTE_CRYPTO_CIPHER_NULL) && + (ses->auth_alg == RTE_CRYPTO_AUTH_NULL)); +} + +static inline void +caam_cipher_alg(struct caam_jr_session *ses, struct alginfo *alginfo_c) +{ + switch (ses->cipher_alg) { + case RTE_CRYPTO_CIPHER_NULL: + break; + case RTE_CRYPTO_CIPHER_AES_CBC: + alginfo_c->algtype = OP_ALG_ALGSEL_AES; + alginfo_c->algmode = OP_ALG_AAI_CBC; + break; + case RTE_CRYPTO_CIPHER_3DES_CBC: + alginfo_c->algtype = OP_ALG_ALGSEL_3DES; + alginfo_c->algmode = OP_ALG_AAI_CBC; + break; + case RTE_CRYPTO_CIPHER_AES_CTR: + alginfo_c->algtype = OP_ALG_ALGSEL_AES; + alginfo_c->algmode = OP_ALG_AAI_CTR; + break; + default: + CAAM_JR_DEBUG("unsupported cipher alg %d", ses->cipher_alg); + } +} + +/* prepare command block of the session */ +static int +caam_jr_prep_cdb(struct caam_jr_session *ses) +{ + struct alginfo alginfo_c = {0}; + int32_t shared_desc_len = 0; + struct sec_cdb *cdb; +#if RTE_BYTE_ORDER == RTE_BIG_ENDIAN + int swap = false; +#else + int swap = true; +#endif + + if (ses->cdb) + caam_jr_dma_free(ses->cdb); + + cdb = caam_jr_dma_mem_alloc(L1_CACHE_BYTES, sizeof(struct sec_cdb)); + if (!cdb) { + CAAM_JR_ERR("failed to allocate memory for cdb\n"); + return -1; + } + + ses->cdb = cdb; + + memset(cdb, 0, sizeof(struct sec_cdb)); + + if (is_cipher_only(ses)) { + caam_cipher_alg(ses, &alginfo_c); + if (alginfo_c.algtype == (unsigned int)CAAM_JR_ALG_UNSUPPORT) { + CAAM_JR_ERR("not supported cipher alg"); + rte_free(cdb); + return -ENOTSUP; + } + + alginfo_c.key = (size_t)ses->cipher_key.data; + alginfo_c.keylen = ses->cipher_key.length; + alginfo_c.key_enc_flags = 0; + alginfo_c.key_type = RTA_DATA_IMM; + + shared_desc_len = cnstr_shdsc_blkcipher( + cdb->sh_desc, true, + swap, &alginfo_c, + NULL, + ses->iv.length, + ses->dir); + } + + if (shared_desc_len < 0) { + CAAM_JR_ERR("error in preparing command block"); + return shared_desc_len; + } + +#ifdef RTE_LIBRTE_PMD_CAAM_JR_DEBUG + SEC_DUMP_DESC(cdb->sh_desc); +#endif + + cdb->sh_hdr.hi.field.idlen = shared_desc_len; + + return 0; +} + /* @brief Poll the HW for already processed jobs in the JR * and silently discard the available jobs or notify them to UA * with indicated error code. @@ -105,6 +242,486 @@ static void hw_flush_job_ring(struct sec_job_ring_t *job_ring, } } +/* @brief Poll the HW for already processed jobs in the JR + * and notify the available jobs to UA. + * + * @param [in] job_ring The job ring to poll. + * @param [in] limit The maximum number of jobs to notify. + * If set to negative value, all available jobs are + * notified. + * + * @retval >=0 for No of jobs notified to UA. + * @retval -1 for error + */ +static int +hw_poll_job_ring(struct sec_job_ring_t *job_ring, + struct rte_crypto_op **ops, int32_t limit, + struct caam_jr_qp *jr_qp) +{ + int32_t jobs_no_to_notify = 0; /* the number of done jobs to notify*/ + int32_t number_of_jobs_available = 0; + int32_t notified_descs_no = 0; + uint32_t sec_error_code = 0; + struct job_descriptor *current_desc; + phys_addr_t current_desc_addr; + phys_addr_t *temp_addr; + struct caam_jr_op_ctx *ctx; + + /* TODO check for ops have memory*/ + /* check here if any JR error that cannot be written + * in the output status word has occurred + */ + if (JR_REG_JRINT_JRE_EXTRACT(GET_JR_REG(JRINT, job_ring))) { + CAAM_JR_INFO("err received"); + sec_error_code = JR_REG_JRINT_ERR_TYPE_EXTRACT( + GET_JR_REG(JRINT, job_ring)); + if (unlikely(sec_error_code)) { + hw_job_ring_error_print(job_ring, sec_error_code); + return -1; + } + } + /* compute the number of jobs available in the job ring based on the + * producer and consumer index values. + */ + number_of_jobs_available = hw_get_no_finished_jobs(job_ring); + /* Compute the number of notifications that need to be raised to UA + * If limit > total number of done jobs -> notify all done jobs + * If limit = 0 -> error + * If limit < total number of done jobs -> notify a number + * of done jobs equal with limit + */ + jobs_no_to_notify = (limit > number_of_jobs_available) ? + number_of_jobs_available : limit; + CAAM_JR_DP_DEBUG( + "Jr[%p] pi[%d] ci[%d].limit =%d Available=%d.Jobs to notify=%d", + job_ring, job_ring->pidx, job_ring->cidx, + limit, number_of_jobs_available, jobs_no_to_notify); + + rte_smp_rmb(); + + while (jobs_no_to_notify > notified_descs_no) { + static uint64_t false_alarm; + static uint64_t real_poll; + + /* Get job status here */ + sec_error_code = job_ring->output_ring[job_ring->cidx].status; + /* Get completed descriptor */ + temp_addr = &(job_ring->output_ring[job_ring->cidx].desc); + current_desc_addr = (phys_addr_t)sec_read_addr(temp_addr); + + real_poll++; + /* todo check if it is false alarm no desc present */ + if (!current_desc_addr) { + false_alarm++; + printf("false alarm %" PRIu64 "real %" PRIu64 + " sec_err =0x%x cidx Index =0%d\n", + false_alarm, real_poll, + sec_error_code, job_ring->cidx); + rte_panic("CAAM JR descriptor NULL"); + return notified_descs_no; + } + current_desc = (struct job_descriptor *) + caam_jr_dma_ptov(current_desc_addr); + /* now increment the consumer index for the current job ring, + * AFTER saving job in temporary location! + */ + job_ring->cidx = SEC_CIRCULAR_COUNTER(job_ring->cidx, + SEC_JOB_RING_SIZE); + /* Signal that the job has been processed and the slot is free*/ + hw_remove_entries(job_ring, 1); + /*TODO for multiple ops, packets*/ + ctx = container_of(current_desc, struct caam_jr_op_ctx, jobdes); + if (unlikely(sec_error_code)) { + CAAM_JR_ERR("desc at cidx %d generated error 0x%x\n", + job_ring->cidx, sec_error_code); + hw_handle_job_ring_error(job_ring, sec_error_code); + //todo improve with exact errors + ctx->op->status = RTE_CRYPTO_OP_STATUS_ERROR; + jr_qp->rx_errs++; + } else { + ctx->op->status = RTE_CRYPTO_OP_STATUS_SUCCESS; +#ifdef RTE_LIBRTE_PMD_CAAM_JR_DEBUG + if (ctx->op->sym->m_dst) { + rte_hexdump(stdout, "PROCESSED", + rte_pktmbuf_mtod(ctx->op->sym->m_dst, void *), + rte_pktmbuf_data_len(ctx->op->sym->m_dst)); + } else { + rte_hexdump(stdout, "PROCESSED", + rte_pktmbuf_mtod(ctx->op->sym->m_src, void *), + rte_pktmbuf_data_len(ctx->op->sym->m_src)); + } +#endif + } + if (ctx->op->sess_type == RTE_CRYPTO_OP_SECURITY_SESSION) { + struct ip *ip4_hdr; + + if (ctx->op->sym->m_dst) { + /*TODO check for ip header or other*/ + ip4_hdr = (struct ip *)rte_pktmbuf_mtod(ctx->op->sym->m_dst, char*); + ctx->op->sym->m_dst->pkt_len = + rte_be_to_cpu_16(ip4_hdr->ip_len); + ctx->op->sym->m_dst->data_len = + rte_be_to_cpu_16(ip4_hdr->ip_len); + } else { + ip4_hdr = (struct ip *)rte_pktmbuf_mtod(ctx->op->sym->m_src, char*); + ctx->op->sym->m_src->pkt_len = + rte_be_to_cpu_16(ip4_hdr->ip_len); + ctx->op->sym->m_src->data_len = + rte_be_to_cpu_16(ip4_hdr->ip_len); + } + } + *ops = ctx->op; + caam_jr_op_ending(ctx); + ops++; + notified_descs_no++; + } + return notified_descs_no; +} + +static uint16_t +caam_jr_dequeue_burst(void *qp, struct rte_crypto_op **ops, + uint16_t nb_ops) +{ + struct caam_jr_qp *jr_qp = (struct caam_jr_qp *)qp; + struct sec_job_ring_t *ring = jr_qp->ring; + int num_rx; + int ret; + + CAAM_JR_DP_DEBUG("Jr[%p]Polling. limit[%d]", ring, nb_ops); + + /* Poll job ring + * If nb_ops < 0 -> poll JR until no more notifications are available. + * If nb_ops > 0 -> poll JR until limit is reached. + */ + + /* Run hw poll job ring */ + num_rx = hw_poll_job_ring(ring, ops, nb_ops, jr_qp); + if (num_rx < 0) { + CAAM_JR_ERR("Error polling SEC engine (%d)", num_rx); + return 0; + } + + CAAM_JR_DP_DEBUG("Jr[%p].Jobs notified[%d]. ", ring, num_rx); + + if (ring->jr_mode == SEC_NOTIFICATION_TYPE_NAPI) { + if (num_rx < nb_ops) { + ret = caam_jr_enable_irqs(ring->irq_fd); + SEC_ASSERT(ret == 0, ret, + "Failed to enable irqs for job ring %p", ring); + } + } else if (ring->jr_mode == SEC_NOTIFICATION_TYPE_IRQ) { + + /* Always enable IRQ generation when in pure IRQ mode */ + ret = caam_jr_enable_irqs(ring->irq_fd); + SEC_ASSERT(ret == 0, ret, + "Failed to enable irqs for job ring %p", ring); + } + + jr_qp->rx_pkts += num_rx; + + return num_rx; +} + + +static inline struct caam_jr_op_ctx * +build_cipher_only_sg(struct rte_crypto_op *op, struct caam_jr_session *ses) +{ + struct rte_crypto_sym_op *sym = op->sym; + struct rte_mbuf *mbuf = sym->m_src; + struct caam_jr_op_ctx *ctx; + struct sec4_sg_entry *sg, *in_sg; + int length; + struct sec_cdb *cdb; + uint64_t sdesc_offset; + uint8_t *IV_ptr = rte_crypto_op_ctod_offset(op, uint8_t *, + ses->iv.offset); + struct sec_job_descriptor_t *jobdescr; + uint8_t reg_segs; + + if (sym->m_dst) { + mbuf = sym->m_dst; + reg_segs = mbuf->nb_segs + sym->m_src->nb_segs + 2; + } else { + mbuf = sym->m_src; + reg_segs = mbuf->nb_segs * 2 + 2; + } + + if (reg_segs > MAX_SG_ENTRIES) { + CAAM_JR_DP_ERR("Cipher: Max sec segs supported is %d", + MAX_SG_ENTRIES); + return NULL; + } + + ctx = caam_jr_alloc_ctx(ses); + if (!ctx) + return NULL; + + ctx->op = op; + cdb = ses->cdb; + sdesc_offset = (size_t) ((char *)&cdb->sh_desc - (char *)cdb); + + jobdescr = (struct sec_job_descriptor_t *) ctx->jobdes.desc; + + SEC_JD_INIT(jobdescr); + SEC_JD_SET_SD(jobdescr, + (phys_addr_t)(caam_jr_dma_vtop(cdb)) + sdesc_offset, + cdb->sh_hdr.hi.field.idlen); + +#ifdef RTE_LIBRTE_PMD_CAAM_JR_DEBUG + CAAM_JR_INFO("mbuf offset =%d, cipher offset = %d, length =%d+%d", + sym->m_src->data_off, sym->cipher.data.offset, + sym->cipher.data.length, ses->iv.length); +#endif + /* output */ + if (sym->m_dst) + mbuf = sym->m_dst; + else + mbuf = sym->m_src; + + sg = &ctx->sg[0]; + length = sym->cipher.data.length; + + sg->ptr = cpu_to_caam64(rte_pktmbuf_iova(mbuf) + + sym->cipher.data.offset); + sg->len = cpu_to_caam32(mbuf->data_len - sym->cipher.data.offset); + + /* Successive segs */ + mbuf = mbuf->next; + while (mbuf) { + sg++; + sg->ptr = cpu_to_caam64(rte_pktmbuf_iova(mbuf)); + sg->len = cpu_to_caam32(mbuf->data_len); + mbuf = mbuf->next; + } + /* last element*/ + sg->len |= cpu_to_caam32(SEC4_SG_LEN_FIN); + + SEC_JD_SET_OUT_PTR(jobdescr, + (uint64_t)caam_jr_vtop_ctx(ctx, &ctx->sg[0]), 0, + length); + /*enabling sg bit */ + (jobdescr)->seq_out.command.word |= 0x01000000; + + /*input */ + sg++; + mbuf = sym->m_src; + in_sg = sg; + + length = sym->cipher.data.length + ses->iv.length; + + /* IV */ + sg->ptr = cpu_to_caam64(caam_jr_dma_vtop(IV_ptr)); + sg->len = cpu_to_caam32(ses->iv.length); + + /* 1st seg */ + sg++; + sg->ptr = cpu_to_caam64(rte_pktmbuf_iova(mbuf) + + sym->cipher.data.offset); + sg->len = cpu_to_caam32(mbuf->data_len - sym->cipher.data.offset); + + /* Successive segs */ + mbuf = mbuf->next; + while (mbuf) { + sg++; + sg->ptr = cpu_to_caam64(rte_pktmbuf_iova(mbuf)); + sg->len = cpu_to_caam32(mbuf->data_len); + mbuf = mbuf->next; + } + /* last element*/ + sg->len |= cpu_to_caam32(SEC4_SG_LEN_FIN); + + + SEC_JD_SET_IN_PTR(jobdescr, (uint64_t)caam_jr_vtop_ctx(ctx, in_sg), 0, + length); + /*enabling sg bit */ + (jobdescr)->seq_in.command.word |= 0x01000000; + + return ctx; +} + +static inline struct caam_jr_op_ctx * +build_cipher_only(struct rte_crypto_op *op, struct caam_jr_session *ses) +{ + struct rte_crypto_sym_op *sym = op->sym; + struct caam_jr_op_ctx *ctx; + struct sec4_sg_entry *sg; + rte_iova_t src_start_addr, dst_start_addr; + struct sec_cdb *cdb; + uint64_t sdesc_offset; + uint8_t *IV_ptr = rte_crypto_op_ctod_offset(op, uint8_t *, + ses->iv.offset); + struct sec_job_descriptor_t *jobdescr; + + ctx = caam_jr_alloc_ctx(ses); + if (!ctx) + return NULL; + + ctx->op = op; + cdb = ses->cdb; + sdesc_offset = (size_t) ((char *)&cdb->sh_desc - (char *)cdb); + + src_start_addr = rte_pktmbuf_iova(sym->m_src); + if (sym->m_dst) + dst_start_addr = rte_pktmbuf_iova(sym->m_dst); + else + dst_start_addr = src_start_addr; + + jobdescr = (struct sec_job_descriptor_t *) ctx->jobdes.desc; + + SEC_JD_INIT(jobdescr); + SEC_JD_SET_SD(jobdescr, + (phys_addr_t)(caam_jr_dma_vtop(cdb)) + sdesc_offset, + cdb->sh_hdr.hi.field.idlen); + +#ifdef RTE_LIBRTE_PMD_CAAM_JR_DEBUG + CAAM_JR_INFO("mbuf offset =%d, cipher offset = %d, length =%d+%d", + sym->m_src->data_off, sym->cipher.data.offset, + sym->cipher.data.length, ses->iv.length); +#endif + /* output */ + SEC_JD_SET_OUT_PTR(jobdescr, (uint64_t)dst_start_addr, + sym->cipher.data.offset, + sym->cipher.data.length + ses->iv.length); + + /*input */ + sg = &ctx->sg[0]; + SEC_JD_SET_IN_PTR(jobdescr, (uint64_t)caam_jr_vtop_ctx(ctx, sg), 0, + sym->cipher.data.length + ses->iv.length); + /*enabling sg bit */ + (jobdescr)->seq_in.command.word |= 0x01000000; + + sg->ptr = cpu_to_caam64(caam_jr_dma_vtop(IV_ptr)); + sg->len = cpu_to_caam32(ses->iv.length); + + sg = &ctx->sg[1]; + sg->ptr = cpu_to_caam64(src_start_addr + sym->cipher.data.offset); + sg->len = cpu_to_caam32(sym->cipher.data.length); + /* last element*/ + sg->len |= cpu_to_caam32(SEC4_SG_LEN_FIN); + + return ctx; +} + +static int +caam_jr_enqueue_op(struct rte_crypto_op *op, struct caam_jr_qp *qp) +{ + struct sec_job_ring_t *ring = qp->ring; + struct caam_jr_session *ses; + struct caam_jr_op_ctx *ctx = NULL; + struct sec_job_descriptor_t *jobdescr __rte_unused; + + switch (op->sess_type) { + case RTE_CRYPTO_OP_WITH_SESSION: + ses = (struct caam_jr_session *) + get_sym_session_private_data(op->sym->session, + cryptodev_driver_id); + break; + default: + CAAM_JR_DP_ERR("sessionless crypto op not supported"); + qp->tx_errs++; + return -1; + } + + if (unlikely(!ses->qp || ses->qp != qp)) { + CAAM_JR_DP_DEBUG("Old:sess->qp=%p New qp = %p\n", ses->qp, qp); + ses->qp = qp; + caam_jr_prep_cdb(ses); + } + + if (rte_pktmbuf_is_contiguous(op->sym->m_src)) { + if (is_cipher_only(ses)) + ctx = build_cipher_only(op, ses); + } else { + if (is_cipher_only(ses)) + ctx = build_cipher_only_sg(op, ses); + } + if (unlikely(!ctx)) { + qp->tx_errs++; + CAAM_JR_ERR("not supported sec op"); + return -1; + } +#ifdef RTE_LIBRTE_PMD_CAAM_JR_DEBUG + if (is_decode(ses)) + rte_hexdump(stdout, "DECODE", + rte_pktmbuf_mtod(op->sym->m_src, void *), + rte_pktmbuf_data_len(op->sym->m_src)); + else + rte_hexdump(stdout, "ENCODE", + rte_pktmbuf_mtod(op->sym->m_src, void *), + rte_pktmbuf_data_len(op->sym->m_src)); + + printf("\n JD before conversion\n"); + for (int i = 0; i < 12; i++) + printf("\n 0x%08x", ctx->jobdes.desc[i]); +#endif + + CAAM_JR_DP_DEBUG("Jr[%p] pi[%d] ci[%d].Before sending desc", + ring, ring->pidx, ring->cidx); + + /* todo - do we want to retry */ + if (SEC_JOB_RING_IS_FULL(ring->pidx, ring->cidx, + SEC_JOB_RING_SIZE, SEC_JOB_RING_SIZE)) { + CAAM_JR_DP_DEBUG("Ring FULL Jr[%p] pi[%d] ci[%d].Size = %d", + ring, ring->pidx, ring->cidx, SEC_JOB_RING_SIZE); + caam_jr_op_ending(ctx); + qp->tx_ring_full++; + return -EBUSY; + } + +#if CORE_BYTE_ORDER != CAAM_BYTE_ORDER + jobdescr = (struct sec_job_descriptor_t *) ctx->jobdes.desc; + + jobdescr->deschdr.command.word = + cpu_to_caam32(jobdescr->deschdr.command.word); + jobdescr->sd_ptr = cpu_to_caam64(jobdescr->sd_ptr); + jobdescr->seq_out.command.word = + cpu_to_caam32(jobdescr->seq_out.command.word); + jobdescr->seq_out_ptr = cpu_to_caam64(jobdescr->seq_out_ptr); + jobdescr->out_ext_length = cpu_to_caam32(jobdescr->out_ext_length); + jobdescr->seq_in.command.word = + cpu_to_caam32(jobdescr->seq_in.command.word); + jobdescr->seq_in_ptr = cpu_to_caam64(jobdescr->seq_in_ptr); + jobdescr->in_ext_length = cpu_to_caam32(jobdescr->in_ext_length); + jobdescr->load_dpovrd.command.word = + cpu_to_caam32(jobdescr->load_dpovrd.command.word); + jobdescr->dpovrd = cpu_to_caam32(jobdescr->dpovrd); +#endif + + /* Set ptr in input ring to current descriptor */ + sec_write_addr(&ring->input_ring[ring->pidx], + (phys_addr_t)caam_jr_vtop_ctx(ctx, ctx->jobdes.desc)); + rte_smp_wmb(); + + /* Notify HW that a new job is enqueued */ + hw_enqueue_desc_on_job_ring(ring); + + /* increment the producer index for the current job ring */ + ring->pidx = SEC_CIRCULAR_COUNTER(ring->pidx, SEC_JOB_RING_SIZE); + + return 0; +} + +static uint16_t +caam_jr_enqueue_burst(void *qp, struct rte_crypto_op **ops, + uint16_t nb_ops) +{ + /* Function to transmit the frames to given device and queuepair */ + uint32_t loop; + int32_t ret; + struct caam_jr_qp *jr_qp = (struct caam_jr_qp *)qp; + uint16_t num_tx = 0; + /*Prepare each packet which is to be sent*/ + for (loop = 0; loop < nb_ops; loop++) { + ret = caam_jr_enqueue_op(ops[loop], jr_qp); + if (!ret) + num_tx++; + } + + jr_qp->tx_pkts += num_tx; + + return num_tx; +} + /* Release queue pair */ static int caam_jr_queue_pair_release(struct rte_cryptodev *dev, @@ -642,8 +1259,8 @@ caam_jr_dev_init(const char *name, dev->dev_ops = &caam_jr_ops; /* register rx/tx burst functions for data path */ - dev->dequeue_burst = NULL; - dev->enqueue_burst = NULL; + dev->dequeue_burst = caam_jr_dequeue_burst; + dev->enqueue_burst = caam_jr_enqueue_burst; dev->feature_flags = RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO | RTE_CRYPTODEV_FF_HW_ACCELERATED | RTE_CRYPTODEV_FF_SYM_OPERATION_CHAINING | diff --git a/drivers/crypto/caam_jr/caam_jr_desc.h b/drivers/crypto/caam_jr/caam_jr_desc.h new file mode 100644 index 000000000..47c3adf72 --- /dev/null +++ b/drivers/crypto/caam_jr/caam_jr_desc.h @@ -0,0 +1,289 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright 2017-2018 NXP + */ + +#ifndef CAAM_JR_DESC_H +#define CAAM_JR_DESC_H + +#define CMD_HDR_CTYPE_SD 0x16 +#define CMD_HDR_CTYPE_JD 0x17 + +/* The maximum size of a SEC descriptor, in WORDs (32 bits). */ +#define MAX_DESC_SIZE_WORDS 64 + +/* + * Macros manipulating descriptors + */ +/* Macro for setting the SD pointer in a JD. Common for all protocols + * supported by the SEC driver. + */ +#define SEC_JD_SET_SD(descriptor, ptr, len) { \ + (descriptor)->sd_ptr = (ptr); \ + (descriptor)->deschdr.command.jd.shr_desc_len = (len); \ +} + +/* Macro for setting a pointer to the job which this descriptor processes. + * It eases the lookup procedure for identifying the descriptor that has + * completed. + */ +#define SEC_JD_SET_JOB_PTR(descriptor, ptr) \ + ((descriptor)->job_ptr = (ptr)) + +/* Macro for setting up a JD. The structure of the JD is common across all + * supported protocols, thus its structure is identical. + */ +#define SEC_JD_INIT(descriptor) ({ \ + /* CTYPE = job descriptor \ + * RSMS, DNR = 0 + * ONE = 1 + * Start Index = 0 + * ZRO,TD, MTD = 0 + * SHR = 1 (there's a shared descriptor referenced + * by this job descriptor,pointer in next word) + * REO = 1 (execute job descr. first, shared descriptor + * after) + * SHARE = DEFER + * Descriptor Length = 0 ( to be completed @ runtime ) + */ \ + (descriptor)->deschdr.command.word = 0xB0801C0D; \ + /* + * CTYPE = SEQ OUT command * Scater Gather Flag = 0 + * (can be updated @ runtime) PRE = 0 * EXT = 1 + * (data length is in next word, following the * command) + * RTO = 0 + */ \ + (descriptor)->seq_out.command.word = 0xF8400000; /**/ \ + /* + * CTYPE = SEQ IN command + * Scater Gather Flag = 0 (can be updated @ runtime) + * PRE = 0 + * EXT = 1 ( data length is in next word, following the + * command) + * RTO = 0 + */ \ + (descriptor)->seq_in.command.word = 0xF0400000; /**/ \ + /* + * In order to be compatible with QI scenarios, the DPOVRD value + * loaded must be formated like this: + * DPOVRD_EN (1b) | Res| DPOVRD Value (right aligned). + */ \ + (descriptor)->load_dpovrd.command.word = 0x16870004; \ + /* By default, DPOVRD mechanism is disabled, thus the value to be + * LOAD-ed through the above descriptor command will be 0x0000_0000. + */ \ + (descriptor)->dpovrd = 0x00000000; \ +}) + +/* Macro for setting the pointer to the input buffer in the JD, according to + * the parameters set by the user in the ::sec_packet_t structure. + */ +#define SEC_JD_SET_IN_PTR(descriptor, phys_addr, offset, length) { \ + (descriptor)->seq_in_ptr = (phys_addr) + (offset); \ + (descriptor)->in_ext_length = (length); \ +} + +/* Macro for setting the pointer to the output buffer in the JD, according to + * the parameters set by the user in the ::sec_packet_t structure. + */ +#define SEC_JD_SET_OUT_PTR(descriptor, phys_addr, offset, length) { \ + (descriptor)->seq_out_ptr = (phys_addr) + (offset); \ + (descriptor)->out_ext_length = (length); \ +} + +/* Macro for setting the Scatter-Gather flag in the SEQ IN command. Used in + * case the input buffer is split in multiple buffers, according to the user + * specification. + */ +#define SEC_JD_SET_SG_IN(descriptor) \ + ((descriptor)->seq_in.command.field.sgf = 1) + +/* Macro for setting the Scatter-Gather flag in the SEQ OUT command. Used in + * case the output buffer is split in multiple buffers, according to the user + * specification. + */ +#define SEC_JD_SET_SG_OUT(descriptor) \ + ((descriptor)->seq_out.command.field.sgf = 1) + +#define SEC_JD_SET_DPOVRD(descriptor) \ + +/* Macro for retrieving a descriptor's length. Works for both SD and JD. */ +#define SEC_GET_DESC_LEN(descriptor) \ + (((struct descriptor_header_s *)(descriptor))->command.sd.ctype == \ + CMD_HDR_CTYPE_SD ? ((struct descriptor_header_s *) \ + (descriptor))->command.sd.desclen : \ + ((struct descriptor_header_s *)(descriptor))->command.jd.desclen) + +/* Helper macro for dumping the hex representation of a descriptor */ +#define SEC_DUMP_DESC(descriptor) { \ + int __i; \ + CAAM_JR_INFO("Des@ 0x%08x\n", (uint32_t)((uint32_t *)(descriptor)));\ + for (__i = 0; \ + __i < SEC_GET_DESC_LEN(descriptor); \ + __i++) { \ + printf("0x%08x: 0x%08x\n", \ + (uint32_t)(((uint32_t *)(descriptor)) + __i), \ + *(((uint32_t *)(descriptor)) + __i)); \ + } \ +} +/* Union describing a descriptor header. + */ +struct descriptor_header_s { + union { + uint32_t word; + struct { + /* 4 */ unsigned int ctype:5; + /* 5 */ unsigned int res1:2; + /* 7 */ unsigned int dnr:1; + /* 8 */ unsigned int one:1; + /* 9 */ unsigned int res2:1; + /* 10 */ unsigned int start_idx:6; + /* 16 */ unsigned int res3:2; + /* 18 */ unsigned int cif:1; + /* 19 */ unsigned int sc:1; + /* 20 */ unsigned int pd:1; + /* 21 */ unsigned int res4:1; + /* 22 */ unsigned int share:2; + /* 24 */ unsigned int res5:2; + /* 26 */ unsigned int desclen:6; + } sd; + struct { + /* TODO only below struct members are corrected, + * all others also need to be reversed please verify it + */ + /* 0 */ unsigned int desclen:7; + /* 7 */ unsigned int res4:1; + /* 8 */ unsigned int share:3; + /* 11 */ unsigned int reo:1; + /* 12 */ unsigned int shr:1; + /* 13 */ unsigned int mtd:1; + /* 14 */ unsigned int td:1; + /* 15 */ unsigned int zero:1; + /* 16 */ unsigned int shr_desc_len:6; + /* 22 */ unsigned int res2:1; + /* 23 */ unsigned int one:1; + /* 24 */ unsigned int dnr:1; + /* 25 */ unsigned int rsms:1; + /* 26 */ unsigned int res1:1; + /* 27 */ unsigned int ctype:5; + } jd; + } __rte_packed command; +} __rte_packed; + +/* Union describing a KEY command in a descriptor. + */ +struct key_command_s { + union { + uint32_t word; + struct { + unsigned int ctype:5; + unsigned int cls:2; + unsigned int sgf:1; + unsigned int imm:1; + unsigned int enc:1; + unsigned int nwb:1; + unsigned int ekt:1; + unsigned int kdest:4; + unsigned int tk:1; + unsigned int rsvd1:5; + unsigned int length:10; + } __rte_packed field; + } __rte_packed command; +} __rte_packed; + +/* Union describing a PROTOCOL command + * in a descriptor. + */ +struct protocol_operation_command_s { + union { + uint32_t word; + struct { + unsigned int ctype:5; + unsigned int optype:3; + unsigned char protid; + unsigned short protinfo; + } __rte_packed field; + } __rte_packed command; +} __rte_packed; + +/* Union describing a SEQIN command in a + * descriptor. + */ +struct seq_in_command_s { + union { + uint32_t word; + struct { + unsigned int ctype:5; + unsigned int res1:1; + unsigned int inl:1; + unsigned int sgf:1; + unsigned int pre:1; + unsigned int ext:1; + unsigned int rto:1; + unsigned int rjd:1; + unsigned int res2:4; + unsigned int length:16; + } field; + } __rte_packed command; +} __rte_packed; + +/* Union describing a SEQOUT command in a + * descriptor. + */ +struct seq_out_command_s { + union { + uint32_t word; + struct { + unsigned int ctype:5; + unsigned int res1:2; + unsigned int sgf:1; + unsigned int pre:1; + unsigned int ext:1; + unsigned int rto:1; + unsigned int res2:5; + unsigned int length:16; + } field; + } __rte_packed command; +} __rte_packed; + +struct load_command_s { + union { + uint32_t word; + struct { + unsigned int ctype:5; + unsigned int class:2; + unsigned int sgf:1; + unsigned int imm:1; + unsigned int dst:7; + unsigned char offset; + unsigned char length; + } fields; + } __rte_packed command; +} __rte_packed; + +/* Structure encompassing a general shared descriptor of maximum + * size (64 WORDs). Usually, other specific shared descriptor structures + * will be type-casted to this one + * this one. + */ +struct sec_sd_t { + uint32_t rsvd[MAX_DESC_SIZE_WORDS]; +} __attribute__((packed, aligned(64))); + +/* Structure encompassing a job descriptor which processes + * a single packet from a context. The job descriptor references + * a shared descriptor from a SEC context. + */ +struct sec_job_descriptor_t { + struct descriptor_header_s deschdr; + dma_addr_t sd_ptr; + struct seq_out_command_s seq_out; + dma_addr_t seq_out_ptr; + uint32_t out_ext_length; + struct seq_in_command_s seq_in; + dma_addr_t seq_in_ptr; + uint32_t in_ext_length; + struct load_command_s load_dpovrd; + uint32_t dpovrd; +} __attribute__((packed, aligned(64))); + +#endif From patchwork Thu Sep 13 06:08:44 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Gagandeep Singh X-Patchwork-Id: 44644 X-Patchwork-Delegate: gakhil@marvell.com Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 9E2B35F1A; Thu, 13 Sep 2018 08:09:47 +0200 (CEST) Received: from EUR02-VE1-obe.outbound.protection.outlook.com (mail-eopbgr20076.outbound.protection.outlook.com [40.107.2.76]) by dpdk.org (Postfix) with ESMTP id 2474B58CB for ; Thu, 13 Sep 2018 08:09:38 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=2dUBZ8AVMbIbhd+ZqNVstCyjeutCh0vkpYY/XA1e7OA=; b=QPI0M924FPdaH7VAIZ1EoR0bzopihukD1a9rsdMad77Etdca0xNFukRqiVe2CW/kml9/VtIBIENYdZU/1L0fgRL+8r55HzdAoMhlBoHJ7mR/gCnWN3LhvdNQc5XS/IQfuYvffG8QmZqsX/Iz0gaGutJFzN4Cbh+iXBAyPufbJeE= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=G.Singh@nxp.com; Received: from Tophie.ap.freescale.net (14.142.187.166) by HE1PR04MB1529.eurprd04.prod.outlook.com (2a01:111:e400:59a8::19) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1143.15; Thu, 13 Sep 2018 06:09:34 +0000 From: Gagandeep Singh To: dev@dpdk.org, akhil.goyal@nxp.com Cc: Hemant Agrawal , Gagandeep Singh Date: Thu, 13 Sep 2018 11:38:44 +0530 Message-Id: <20180913060846.29930-9-g.singh@nxp.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20180913060846.29930-1-g.singh@nxp.com> References: <20180913060846.29930-1-g.singh@nxp.com> MIME-Version: 1.0 X-Originating-IP: [14.142.187.166] X-ClientProxiedBy: BM1PR01CA0095.INDPRD01.PROD.OUTLOOK.COM (2603:1096:b00::11) To HE1PR04MB1529.eurprd04.prod.outlook.com (2a01:111:e400:59a8::19) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 3888705f-f368-43be-20ec-08d6193f7b1b X-MS-Office365-Filtering-HT: Tenant X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989137)(4534165)(7168020)(4627221)(201703031133081)(201702281549075)(8990107)(5600074)(711020)(4618075)(2017052603328)(7153060)(7193020); SRVR:HE1PR04MB1529; X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 3:puaDeqrzj/Au1S/o2li1oNSg4dl4Sf2QflkVHN5m4OqF4Vt+nZlE792fi7ZV7sjTY6Z9iRAYLv94gh9o72oSwhVaU0K2ePGDDYJAQl4V3TIpnhVd07kv6kcwHoGt2xc4+LV2XvnFdQM/2nnrFCaDg6t/ajWEk0NAjakKF0DZz7zx96DGY9zKQ8vjgQtyLqyJCKqNRoyALM+2MnqjuBZdnsiaiwwJuNbB6Rq5CRqBlZL3GJMWXYdbm/u0E82z+bUc; 25:UpPI2qU5bibnduekbY/tIuXATczDSyqBfTDuBEZQYmeC6lYS7FlHYN9ip9ougf9fe6gtTaG9dygclyDI35FgOuF+kUuR4y/qe2Ay2pnw9oeobXvg6IxxipvmHbYcWGisyCk/vEJudeK/9OwzccqztvyVjTo+XDdCIBWoIbkVwiJRlrEvsP0uGf4A4yf1q0e7hvQyp0v/vSM2fatG792iRyiR0np/I/mWcXEX5hYE8Ah2CmHsNpl6+gkXoHDJ+7am5tLOre49hUJlx1o5oVWSkJEiO2x0gydBlWrQIlQo7yetiox3mwoIG49BYI9Ua36ziOcdS/MLslexnCvf8hCYig==; 31:I2orOn0f+AzQiK19udMJ3h00caG1ZFgYU9iNFV5LfNUUHWmjT33ZzwHFwRasHDPzAt+NSmkyS24KpRiNG9vkx3SFO2+Ao/TPrRVswnVWhXiMZUx2OhNl9UboSLHhBIeDTar/hmK5Z/b2vN0WXFfdNiI0aLXVO7w0tJQWw3qm8rOKS5KdpBOytHPLe9xy01pGXvsgGsnA0Md+EW4fIyBypeK92sEX0FdtxguKSFoIDPw= X-MS-TrafficTypeDiagnostic: HE1PR04MB1529: X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 20:oU79fACEjjyEyLKwG7dnl0hQlNp2Yq81SzTXBpgmdAYsxYX9gWJdY5qcUKnxulprpQASq03rNG8SzeJKMeLBsiTgKabVFE2v7VzL4Qp7TVkP5T83QE0wqwyCWbBeGQ68qprpqtZ5eij1x0nGOVwG36sdhv7JJo9xf/ojgUoeIlI9ZMEQYFeXKCMnLtUABxZORAtZl7Iy7w+pgYJaoXzUiQR+cFY9WdMzwZaU4sOiCoGvKse2cQkeoNsTIAv8hnEVW0mMq+DXf/wnY/TLuFaG8kGBQ9U4i4hTIazTvxLUzOFz63q4vsSrtzGm7p/NmBMEo+9GGyVqXf2NizHcCtz4r97c/tj6zqK66QC8KJl7oqAyz7kfONHQjVWo85Zv3WeNh0hJ4nR2T530GqFWdSZCMTwMySwaQJ/wBzKo7V1Fr19FZ3sbRQr1c7chRGMYAavK/APop+AW6Pzt5BoxxuN/ZPSqSb11opJWuDK5KT5HxUE6+anzfwY5S163hgJUPVA8; 4:/rfAlu9+5JyG2zBzLCna+GdgKAHSDrA5zykN01mZdXsbx8bEAuylZSg9kK0flrHzfeEXVhTQluoUXkq+Y80rVYQ2rW+uj6tDMASl9FHaYSdLjvbyjnNKJi/LdEWSXjXE8CwMLpEF9/W8i/xOfp1bXuI19LecVV71FPBrlaXqGbjwVYRY+FQr8QNhR1hgDF4GHrF7fUaUI0Q48soHIdZmr5V4ZNAzAuMwpXpC5BpxrW+YV9UodyAAIUiyjaN8qzoLQjJ+ecadY27605yjmTi88hs4RLCXOOyQBN1Wucd3bJPNBy8WNWIXd84NooecGll0 X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(185117386973197); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(5005006)(8121501046)(823301075)(3231311)(944501410)(52105095)(3002001)(93006095)(93001095)(10201501046)(6055026)(149027)(150027)(6041310)(20161123558120)(20161123562045)(20161123560045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123564045)(201708071742011)(7699050); SRVR:HE1PR04MB1529; BCL:0; PCL:0; RULEID:; SRVR:HE1PR04MB1529; X-Forefront-PRVS: 07943272E1 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(366004)(376002)(39860400002)(136003)(346002)(396003)(189003)(199004)(2906002)(6506007)(386003)(5009440100003)(6486002)(51416003)(6512007)(52116002)(486006)(2616005)(68736007)(956004)(53936002)(476003)(446003)(11346002)(305945005)(26005)(7736002)(55236004)(76176011)(186003)(16526019)(50226002)(478600001)(47776003)(1076002)(3846002)(6116002)(48376002)(105586002)(106356001)(25786009)(14444005)(50466002)(5660300001)(36756003)(72206003)(66066001)(316002)(97736004)(8936002)(81166006)(4326008)(8676002)(86362001)(6636002)(6666003)(54906003)(81156014)(16586007)(110426005); DIR:OUT; SFP:1101; SCL:1; SRVR:HE1PR04MB1529; H:Tophie.ap.freescale.net; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: nxp.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; HE1PR04MB1529; 23:fVhscXPDbv5O+Mv3yUl0OHWJs4LaxWNUHlrNVYB2Y?= TgPXo8Cw1kWqxzpGf76lnKWgkpMEGcFdMhtJSOx82PemahktFEG9A34JprDnhQByip9cUMIfshev2rMOkn5qNWopHAxjT6q/bjAAgSZAjPTVRYPaB12kMWjwa8Qj1jwOXt3M46nADRdeZBV1D64iogTf5bl/jWYWIV+ZDZqr5UcVh1y7G43JB0Hk5+RmlJLAhtkbB3lAJlPxfwQx7yAcrbt1EW066DP6imZr6e9p+DY1Vn7UY0RPZtc+S0/o5uXqrDNWh2MaqaZjbEvJqe342JTIbvh3QCThI2UcnCGVOLaxb0C/JRCCHW9qGYMW1XWTCR+7sjvbgyRbaokv19hFDxpO5mHsOHSoJsqlz3fNOl2EuOcIpzQfPd/czpNiBXPPzjbgEgcPh3n8jgabr745eCerlbzAaXUufpTp1b3iK4YNk8Z3SZCcd/NS2XPFT0DzYFuoBnwoTyqocdXBKDmrgc0Jsjunl5oK54MM6dKQeTnJfdBcsbEp5+to/oUpGOwo08Gwi0dnmYNu+s5mYP/PsCSl94TLz1GEF6dE4tArqIWQtuUoJRpCLFWqaJZrUwy+biFADz0lW/Qypa9qCx6n6HkQp1yEqBeUz88FIH6DO+6NyRG+Cw66UG957/k8CxSgu0Zoz8rhCkZaXScch0kFYDJzzZ0LG5xw5GaMN+nv+BsfY852+sDplxHhTq/ZrOMSUzYHlPVxDsHTCYrV22EbWlJt9DlVxjcLSmziyibm6YCyS9d8kvO3K4YFY4yL7ShOKemuda+Cdbfe0doF2CsJ5FUgO8b1b285GBDvHcRZkFMTqpOvKm1f2dG0CDGNDXgwj30YlBsTDGYCAbQMXDU3YKgROHlnkr17MfbGnrRpvcJ2LseLsq3CfAGO1UjxJfLWXpxyUgEhfkt39MiKwTsxbID/bLVY7dAczkCCZMVYrmeuIwI8vd6Pj7gsMKrjWD267DJgOX4aly61sAF4lAte4m1p1CXfqNRFQqKC8Cqr1fVGovTYHXlaZp+j7f7J6v5iG9XOr96k7Nyf49B+jfBOGxbd6AfjLmFaMkMIR3Dmt9Ai0Sjr6fUEulgV4h7kCwblf7srT9mt3Efvc8jJTmcmUW4lu6piW3lodVrGF6Kgfr+DyNURhawDVrra1a6BFBUkKdfUPByIKA/gx1/puKUPDumtuXNMxVWsUY+bP6oBe1QQhUXtip2s1AQqYduw/fagmDf9/eB3tYmIDB9DXPsY76FPDLX7NMDJYd+8slOLnIP6Poiu+0s2GKYeUYusEAQ6iNDtHWe9m8thM0rChaOYcMq X-Microsoft-Antispam-Message-Info: XSdI/dFkXVfUqgtopnEzriVzuJE2Dpq8KB7aZKeNytIKG1qE37yeyyzEjdlUD+/IH1/JVO8l0vcckP+DgPJzNpI9T4fFJ9l7b+3jdrjKcteeBCIUTpVSoqX1+/CAip7h19IBMJcEx+CH84nDba016UhwB5inVyxKmK6zCR7u3AYOvTM96R7rm9r/2VoFa0JKZrmxusxBFD6j9OXHKarn2PIdH3nR4+MWytZYJldu4shTmMzgdq4fKW9N6lBVq5ujWfs3UCJRaue4F3Ujoy9RuY7HgXFjXlaRzn3XcvSyc79SviEd7trFfzU7cPWqaod5nCIBAIrvBRjhnIaoj2LHpE1STfI3UclqYRdWmjJH/5o= X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 6:DSlpbr7t2DGCZJxq6nvvunBNa9BxnpZFctiu2IMu3oFSCniNNcr01m2CqFuGw3Vl30iIZW0vASwPKlsWxv1ha2I06xQgDYWgPxKcljfF0p5p/e9TKffSpGVd4HnxiHYvyFyKgj52QGS2741G0aIrc9sp+Ft/U3+W5vJ74Syp5bNvaH2+4lJ4UzrxqabSt1sFy+ZHYsA1KjcvQzbcTyKC2kjQIhY56Wpgc0N/46tfKZYsgU17brI+wzl5jixGnoEAihnZZvMYrAciWbV3OVncGI0opXyTuzbfRmK/Y+Ge3ds4LnTm2fgBY9TfEIeQTuI9kOhlwCmdP8nuggOnHHTyXMj3VfBWnjj7n4H+24B90KAlT/wYt5P7wWY/k4VtHsx7Q/qpPz9mXpk+GVZga6wSiZ4cT1u6tkmt2/FodT88U6714hlwfCTCkfnHuurTeJBNMI3B/g+g5fWM/Wllqf69fg==; 5:CETsjxPH0ddxpR8mN5SpKPxLn6QU6iuiQq5S6fDsfCUw733ppqFXpRHqtsxm04rAG8mMDCgsz6W+GxdL/BgIZtay8Ft7Im5sJscEGKAhb8qNJhZBX0GY+8e/XN/UfTwIspbg+cPSDreLUoszH4NX5bEWlq1eVoIINr0Ll3wpOrU=; 7:fujeWX6xOvw8cnaUJ3+unoXgwBqC0naKS0Tv8YFhwme9kJhms2hqX+sTa1fqXegh27L3Y2TA0PKYaOTl8pgjsdNvRzngJpZLCGs2CPFSf89ZH6CpvDFcXMBTS0bFkUulifoaUvPeHFuc1oQFf4y88lDCWVxns+JEBtSMRU3WvXfkml79moRGXOnStERT/ntxQh6CxbwM8/TAPqVH0OLJAuiFf4SGRIcyRqE9w4I5ca7twTLVbe1BQgATiW881r6L SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 13 Sep 2018 06:09:34.6950 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 3888705f-f368-43be-20ec-08d6193f7b1b X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-Transport-CrossTenantHeadersStamped: HE1PR04MB1529 Subject: [dpdk-dev] [PATCH 08/10] crypto/caam_jr: add auth cipher and aead session 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: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Hemant Agrawal Signed-off-by: Gagandeep Singh Signed-off-by: Hemant Agrawal --- drivers/crypto/caam_jr/caam_jr.c | 710 ++++++++++++++++++++++++++++++- 1 file changed, 707 insertions(+), 3 deletions(-) diff --git a/drivers/crypto/caam_jr/caam_jr.c b/drivers/crypto/caam_jr/caam_jr.c index 6d30c4f4d..d582b2fcb 100644 --- a/drivers/crypto/caam_jr/caam_jr.c +++ b/drivers/crypto/caam_jr/caam_jr.c @@ -21,7 +21,9 @@ /* RTA header files */ #include #include +#include #include + #include #include #include @@ -103,6 +105,71 @@ static inline int is_cipher_only(struct caam_jr_session *ses) (ses->auth_alg == RTE_CRYPTO_AUTH_NULL)); } +static inline int is_auth_only(struct caam_jr_session *ses) +{ + return ((ses->cipher_alg == RTE_CRYPTO_CIPHER_NULL) && + (ses->auth_alg != RTE_CRYPTO_AUTH_NULL)); +} + +static inline int is_aead(struct caam_jr_session *ses) +{ + return ((ses->cipher_alg == 0) && + (ses->auth_alg == 0) && + (ses->aead_alg != 0)); +} + +static inline int is_auth_cipher(struct caam_jr_session *ses) +{ + return ((ses->cipher_alg != RTE_CRYPTO_CIPHER_NULL) && + (ses->auth_alg != RTE_CRYPTO_AUTH_NULL)); +} + +static inline int is_encode(struct caam_jr_session *ses) +{ + return ses->dir == DIR_ENC; +} + +static inline int is_decode(struct caam_jr_session *ses) +{ + return ses->dir == DIR_DEC; +} + +static inline void +caam_auth_alg(struct caam_jr_session *ses, struct alginfo *alginfo_a) +{ + switch (ses->auth_alg) { + case RTE_CRYPTO_AUTH_NULL: + ses->digest_length = 0; + break; + case RTE_CRYPTO_AUTH_MD5_HMAC: + alginfo_a->algtype = OP_ALG_ALGSEL_MD5; + alginfo_a->algmode = OP_ALG_AAI_HMAC; + break; + case RTE_CRYPTO_AUTH_SHA1_HMAC: + alginfo_a->algtype = OP_ALG_ALGSEL_SHA1; + alginfo_a->algmode = OP_ALG_AAI_HMAC; + break; + case RTE_CRYPTO_AUTH_SHA224_HMAC: + alginfo_a->algtype = OP_ALG_ALGSEL_SHA224; + alginfo_a->algmode = OP_ALG_AAI_HMAC; + break; + case RTE_CRYPTO_AUTH_SHA256_HMAC: + alginfo_a->algtype = OP_ALG_ALGSEL_SHA256; + alginfo_a->algmode = OP_ALG_AAI_HMAC; + break; + case RTE_CRYPTO_AUTH_SHA384_HMAC: + alginfo_a->algtype = OP_ALG_ALGSEL_SHA384; + alginfo_a->algmode = OP_ALG_AAI_HMAC; + break; + case RTE_CRYPTO_AUTH_SHA512_HMAC: + alginfo_a->algtype = OP_ALG_ALGSEL_SHA512; + alginfo_a->algmode = OP_ALG_AAI_HMAC; + break; + default: + CAAM_JR_DEBUG("unsupported auth alg %u", ses->auth_alg); + } +} + static inline void caam_cipher_alg(struct caam_jr_session *ses, struct alginfo *alginfo_c) { @@ -126,13 +193,27 @@ caam_cipher_alg(struct caam_jr_session *ses, struct alginfo *alginfo_c) } } +static inline void +caam_aead_alg(struct caam_jr_session *ses, struct alginfo *alginfo) +{ + switch (ses->aead_alg) { + case RTE_CRYPTO_AEAD_AES_GCM: + alginfo->algtype = OP_ALG_ALGSEL_AES; + alginfo->algmode = OP_ALG_AAI_GCM; + break; + default: + CAAM_JR_DEBUG("unsupported AEAD alg %d", ses->aead_alg); + } +} + /* prepare command block of the session */ static int caam_jr_prep_cdb(struct caam_jr_session *ses) { - struct alginfo alginfo_c = {0}; + struct alginfo alginfo_c = {0}, alginfo_a = {0}, alginfo = {0}; int32_t shared_desc_len = 0; struct sec_cdb *cdb; + int err; #if RTE_BYTE_ORDER == RTE_BIG_ENDIAN int swap = false; #else @@ -171,6 +252,108 @@ caam_jr_prep_cdb(struct caam_jr_session *ses) NULL, ses->iv.length, ses->dir); + } else if (is_auth_only(ses)) { + caam_auth_alg(ses, &alginfo_a); + if (alginfo_a.algtype == (unsigned int)CAAM_JR_ALG_UNSUPPORT) { + CAAM_JR_ERR("not supported auth alg"); + rte_free(cdb); + return -ENOTSUP; + } + + alginfo_a.key = (size_t)ses->auth_key.data; + alginfo_a.keylen = ses->auth_key.length; + alginfo_a.key_enc_flags = 0; + alginfo_a.key_type = RTA_DATA_IMM; + + shared_desc_len = cnstr_shdsc_hmac(cdb->sh_desc, true, + swap, &alginfo_a, + !ses->dir, + ses->digest_length); + } else if (is_aead(ses)) { + caam_aead_alg(ses, &alginfo); + if (alginfo.algtype == (unsigned int)CAAM_JR_ALG_UNSUPPORT) { + CAAM_JR_ERR("not supported aead alg"); + rte_free(cdb); + return -ENOTSUP; + } + alginfo.key = (size_t)ses->aead_key.data; + alginfo.keylen = ses->aead_key.length; + alginfo.key_enc_flags = 0; + alginfo.key_type = RTA_DATA_IMM; + + if (ses->dir == DIR_ENC) + shared_desc_len = cnstr_shdsc_gcm_encap( + cdb->sh_desc, true, swap, + &alginfo, + ses->iv.length, + ses->digest_length); + else + shared_desc_len = cnstr_shdsc_gcm_decap( + cdb->sh_desc, true, swap, + &alginfo, + ses->iv.length, + ses->digest_length); + } else { + caam_cipher_alg(ses, &alginfo_c); + if (alginfo_c.algtype == (unsigned int)CAAM_JR_ALG_UNSUPPORT) { + CAAM_JR_ERR("not supported cipher alg"); + rte_free(cdb); + return -ENOTSUP; + } + + alginfo_c.key = (size_t)ses->cipher_key.data; + alginfo_c.keylen = ses->cipher_key.length; + alginfo_c.key_enc_flags = 0; + alginfo_c.key_type = RTA_DATA_IMM; + + caam_auth_alg(ses, &alginfo_a); + if (alginfo_a.algtype == (unsigned int)CAAM_JR_ALG_UNSUPPORT) { + CAAM_JR_ERR("not supported auth alg"); + rte_free(cdb); + return -ENOTSUP; + } + + alginfo_a.key = (size_t)ses->auth_key.data; + alginfo_a.keylen = ses->auth_key.length; + alginfo_a.key_enc_flags = 0; + alginfo_a.key_type = RTA_DATA_IMM; + + cdb->sh_desc[0] = alginfo_c.keylen; + cdb->sh_desc[1] = alginfo_a.keylen; + err = rta_inline_query(IPSEC_AUTH_VAR_AES_DEC_BASE_DESC_LEN, + MIN_JOB_DESC_SIZE, + (unsigned int *)cdb->sh_desc, + &cdb->sh_desc[2], 2); + + if (err < 0) { + CAAM_JR_ERR("Crypto: Incorrect key lengths"); + rte_free(cdb); + return err; + } + if (cdb->sh_desc[2] & 1) + alginfo_c.key_type = RTA_DATA_IMM; + else { + alginfo_c.key = (size_t)caam_jr_mem_vtop( + (void *)(size_t)alginfo_c.key); + alginfo_c.key_type = RTA_DATA_PTR; + } + if (cdb->sh_desc[2] & (1<<1)) + alginfo_a.key_type = RTA_DATA_IMM; + else { + alginfo_a.key = (size_t)caam_jr_mem_vtop( + (void *)(size_t)alginfo_a.key); + alginfo_a.key_type = RTA_DATA_PTR; + } + cdb->sh_desc[0] = 0; + cdb->sh_desc[1] = 0; + cdb->sh_desc[2] = 0; + /* Auth_only_len is set as 0 here and it will be + * overwritten in fd for each packet. + */ + shared_desc_len = cnstr_shdsc_authenc(cdb->sh_desc, + true, swap, &alginfo_c, &alginfo_a, + ses->iv.length, 0, + ses->digest_length, ses->dir); } if (shared_desc_len < 0) { @@ -422,6 +605,163 @@ caam_jr_dequeue_burst(void *qp, struct rte_crypto_op **ops, return num_rx; } +/** + * packet looks like: + * |<----data_len------->| + * |ip_header|ah_header|icv|payload| + * ^ + * | + * mbuf->pkt.data + */ +static inline struct caam_jr_op_ctx * +build_auth_only_sg(struct rte_crypto_op *op, struct caam_jr_session *ses) +{ + struct rte_crypto_sym_op *sym = op->sym; + struct rte_mbuf *mbuf = sym->m_src; + struct caam_jr_op_ctx *ctx; + struct sec4_sg_entry *sg; + int length; + struct sec_cdb *cdb; + uint64_t sdesc_offset; + struct sec_job_descriptor_t *jobdescr; + uint8_t extra_segs; + + if (is_decode(ses)) + extra_segs = 2; + else + extra_segs = 1; + + if ((mbuf->nb_segs + extra_segs) > MAX_SG_ENTRIES) { + CAAM_JR_DP_ERR("Auth: Max sec segs supported is %d", + MAX_SG_ENTRIES); + return NULL; + } + + ctx = caam_jr_alloc_ctx(ses); + if (!ctx) + return NULL; + + ctx->op = op; + + cdb = ses->cdb; + sdesc_offset = (size_t) ((char *)&cdb->sh_desc - (char *)cdb); + + jobdescr = (struct sec_job_descriptor_t *) ctx->jobdes.desc; + + SEC_JD_INIT(jobdescr); + SEC_JD_SET_SD(jobdescr, + (phys_addr_t)(caam_jr_dma_vtop(cdb)) + sdesc_offset, + cdb->sh_hdr.hi.field.idlen); + + /* output */ + SEC_JD_SET_OUT_PTR(jobdescr, (uint64_t)sym->auth.digest.phys_addr, + 0, ses->digest_length); + + /*input */ + sg = &ctx->sg[0]; + length = sym->auth.data.length; + sg->ptr = cpu_to_caam64(rte_pktmbuf_iova(mbuf) + sym->auth.data.offset); + sg->len = cpu_to_caam32(mbuf->data_len - sym->auth.data.offset); + + /* Successive segs */ + mbuf = mbuf->next; + while (mbuf) { + sg++; + sg->ptr = cpu_to_caam64(rte_pktmbuf_iova(mbuf)); + sg->len = cpu_to_caam32(mbuf->data_len); + mbuf = mbuf->next; + } + + if (is_decode(ses)) { + /* digest verification case */ + sg++; + /* hash result or digest, save digest first */ + rte_memcpy(ctx->digest, sym->auth.digest.data, + ses->digest_length); +#ifdef RTE_LIBRTE_PMD_CAAM_JR_DEBUG + rte_hexdump(stdout, "ICV", ctx->digest, ses->digest_length); +#endif + sg->ptr = cpu_to_caam64(caam_jr_vtop_ctx(ctx, ctx->digest)); + sg->len = cpu_to_caam32(ses->digest_length); + length += ses->digest_length; + } else { + length -= ses->digest_length; + } + + /* last element*/ + sg->len |= cpu_to_caam32(SEC4_SG_LEN_FIN); + + SEC_JD_SET_IN_PTR(jobdescr, + (uint64_t)caam_jr_vtop_ctx(ctx, &ctx->sg[0]), 0, length); + /* enabling sg list */ + (jobdescr)->seq_in.command.word |= 0x01000000; + + return ctx; +} + +static inline struct caam_jr_op_ctx * +build_auth_only(struct rte_crypto_op *op, struct caam_jr_session *ses) +{ + struct rte_crypto_sym_op *sym = op->sym; + struct caam_jr_op_ctx *ctx; + struct sec4_sg_entry *sg; + rte_iova_t start_addr; + struct sec_cdb *cdb; + uint64_t sdesc_offset; + struct sec_job_descriptor_t *jobdescr; + + ctx = caam_jr_alloc_ctx(ses); + if (!ctx) + return NULL; + + ctx->op = op; + + cdb = ses->cdb; + sdesc_offset = (size_t) ((char *)&cdb->sh_desc - (char *)cdb); + + start_addr = rte_pktmbuf_iova(sym->m_src); + + jobdescr = (struct sec_job_descriptor_t *) ctx->jobdes.desc; + + SEC_JD_INIT(jobdescr); + SEC_JD_SET_SD(jobdescr, + (phys_addr_t)(caam_jr_dma_vtop(cdb)) + sdesc_offset, + cdb->sh_hdr.hi.field.idlen); + + /* output */ + SEC_JD_SET_OUT_PTR(jobdescr, (uint64_t)sym->auth.digest.phys_addr, + 0, ses->digest_length); + + /*input */ + if (is_decode(ses)) { + sg = &ctx->sg[0]; + SEC_JD_SET_IN_PTR(jobdescr, + (uint64_t)caam_jr_vtop_ctx(ctx, sg), 0, + (sym->auth.data.length + ses->digest_length)); + /* enabling sg list */ + (jobdescr)->seq_in.command.word |= 0x01000000; + + /* hash result or digest, save digest first */ + rte_memcpy(ctx->digest, sym->auth.digest.data, + ses->digest_length); + sg->ptr = cpu_to_caam64(start_addr + sym->auth.data.offset); + sg->len = cpu_to_caam32(sym->auth.data.length); + +#ifdef RTE_LIBRTE_PMD_CAAM_JR_DEBUG + rte_hexdump(stdout, "ICV", ctx->digest, ses->digest_length); +#endif + /* let's check digest by hw */ + sg++; + sg->ptr = cpu_to_caam64(caam_jr_vtop_ctx(ctx, ctx->digest)); + sg->len = cpu_to_caam32(ses->digest_length); + /* last element*/ + sg->len |= cpu_to_caam32(SEC4_SG_LEN_FIN); + } else { + SEC_JD_SET_IN_PTR(jobdescr, (uint64_t)start_addr, + sym->auth.data.offset, sym->auth.data.length); + } + return ctx; +} static inline struct caam_jr_op_ctx * build_cipher_only_sg(struct rte_crypto_op *op, struct caam_jr_session *ses) @@ -602,6 +942,269 @@ build_cipher_only(struct rte_crypto_op *op, struct caam_jr_session *ses) return ctx; } +/* For decapsulation: + * Input: + * +----+----------------+--------------------------------+-----+ + * | IV | Auth-only data | Authenticated & Encrypted data | ICV | + * +----+----------------+--------------------------------+-----+ + * Output: + * +----+--------------------------+ + * | Decrypted & authenticated data | + * +----+--------------------------+ + */ + +static inline struct caam_jr_op_ctx * +build_cipher_auth_sg(struct rte_crypto_op *op, struct caam_jr_session *ses) +{ + struct rte_crypto_sym_op *sym = op->sym; + struct caam_jr_op_ctx *ctx; + struct sec4_sg_entry *sg, *out_sg, *in_sg; + struct rte_mbuf *mbuf; + uint32_t length = 0; + struct sec_cdb *cdb; + uint64_t sdesc_offset; + uint8_t req_segs; + uint8_t *IV_ptr = rte_crypto_op_ctod_offset(op, uint8_t *, + ses->iv.offset); + struct sec_job_descriptor_t *jobdescr; + uint32_t auth_only_len; + + auth_only_len = op->sym->auth.data.length - + op->sym->cipher.data.length; + + if (sym->m_dst) { + mbuf = sym->m_dst; + req_segs = mbuf->nb_segs + sym->m_src->nb_segs + 3; + } else { + mbuf = sym->m_src; + req_segs = mbuf->nb_segs * 2 + 3; + } + + if (req_segs > MAX_SG_ENTRIES) { + CAAM_JR_DP_ERR("Cipher-Auth: Max sec segs supported is %d", + MAX_SG_ENTRIES); + return NULL; + } + + ctx = caam_jr_alloc_ctx(ses); + if (!ctx) + return NULL; + + ctx->op = op; + cdb = ses->cdb; + sdesc_offset = (size_t) ((char *)&cdb->sh_desc - (char *)cdb); + + jobdescr = (struct sec_job_descriptor_t *) ctx->jobdes.desc; + + SEC_JD_INIT(jobdescr); + SEC_JD_SET_SD(jobdescr, + (phys_addr_t)(caam_jr_dma_vtop(cdb)) + sdesc_offset, + cdb->sh_hdr.hi.field.idlen); + + /* output */ + if (sym->m_dst) + mbuf = sym->m_dst; + else + mbuf = sym->m_src; + + out_sg = &ctx->sg[0]; + if (is_encode(ses)) + length = sym->auth.data.length + ses->digest_length; + else + length = sym->auth.data.length; + + sg = &ctx->sg[0]; + + /* 1st seg */ + sg->ptr = cpu_to_caam64(rte_pktmbuf_iova(mbuf) + + sym->auth.data.offset); + sg->len = cpu_to_caam32(mbuf->data_len - sym->auth.data.offset); + + /* Successive segs */ + mbuf = mbuf->next; + while (mbuf) { + sg++; + sg->ptr = cpu_to_caam64(rte_pktmbuf_iova(mbuf)); + sg->len = cpu_to_caam32(mbuf->data_len); + mbuf = mbuf->next; + } + + if (is_encode(ses)) { + /* set auth output */ + sg++; + sg->ptr = cpu_to_caam64(sym->auth.digest.phys_addr); + sg->len = cpu_to_caam32(ses->digest_length); + } + /* last element*/ + sg->len |= cpu_to_caam32(SEC4_SG_LEN_FIN); + + SEC_JD_SET_OUT_PTR(jobdescr, + (uint64_t)caam_jr_dma_vtop(out_sg), 0, length); + /* set sg bit */ + (jobdescr)->seq_out.command.word |= 0x01000000; + + /* input */ + sg++; + mbuf = sym->m_src; + in_sg = sg; + if (is_encode(ses)) + length = ses->iv.length + sym->auth.data.length; + else + length = ses->iv.length + sym->auth.data.length + + ses->digest_length; + + sg->ptr = cpu_to_caam64(caam_jr_dma_vtop(IV_ptr)); + sg->len = cpu_to_caam32(ses->iv.length); + + sg++; + /* 1st seg */ + sg->ptr = cpu_to_caam64(rte_pktmbuf_iova(mbuf) + + sym->auth.data.offset); + sg->len = cpu_to_caam32(mbuf->data_len - sym->auth.data.offset); + + /* Successive segs */ + mbuf = mbuf->next; + while (mbuf) { + sg++; + sg->ptr = cpu_to_caam64(rte_pktmbuf_iova(mbuf)); + sg->len = cpu_to_caam32(mbuf->data_len); + mbuf = mbuf->next; + } + + if (is_decode(ses)) { + sg++; + rte_memcpy(ctx->digest, sym->auth.digest.data, + ses->digest_length); + sg->ptr = cpu_to_caam64(caam_jr_dma_vtop(ctx->digest)); + sg->len = cpu_to_caam32(ses->digest_length); + } + /* last element*/ + sg->len |= cpu_to_caam32(SEC4_SG_LEN_FIN); + + SEC_JD_SET_IN_PTR(jobdescr, (uint64_t)caam_jr_dma_vtop(in_sg), 0, + length); + /* set sg bit */ + (jobdescr)->seq_in.command.word |= 0x01000000; + /* Auth_only_len is set as 0 in descriptor and it is + * overwritten here in the jd which will update + * the DPOVRD reg. + */ + if (auth_only_len) + /* set sg bit */ + (jobdescr)->dpovrd = 0x80000000 | auth_only_len; + + return ctx; +} + +static inline struct caam_jr_op_ctx * +build_cipher_auth(struct rte_crypto_op *op, struct caam_jr_session *ses) +{ + struct rte_crypto_sym_op *sym = op->sym; + struct caam_jr_op_ctx *ctx; + struct sec4_sg_entry *sg; + rte_iova_t src_start_addr, dst_start_addr; + uint32_t length = 0; + struct sec_cdb *cdb; + uint64_t sdesc_offset; + uint8_t *IV_ptr = rte_crypto_op_ctod_offset(op, uint8_t *, + ses->iv.offset); + struct sec_job_descriptor_t *jobdescr; + uint32_t auth_only_len; + + auth_only_len = op->sym->auth.data.length - + op->sym->cipher.data.length; + + src_start_addr = rte_pktmbuf_iova(sym->m_src); + if (sym->m_dst) + dst_start_addr = rte_pktmbuf_iova(sym->m_dst); + else + dst_start_addr = src_start_addr; + + ctx = caam_jr_alloc_ctx(ses); + if (!ctx) + return NULL; + + ctx->op = op; + cdb = ses->cdb; + sdesc_offset = (size_t) ((char *)&cdb->sh_desc - (char *)cdb); + + jobdescr = (struct sec_job_descriptor_t *) ctx->jobdes.desc; + + SEC_JD_INIT(jobdescr); + SEC_JD_SET_SD(jobdescr, + (phys_addr_t)(caam_jr_dma_vtop(cdb)) + sdesc_offset, + cdb->sh_hdr.hi.field.idlen); + + /* input */ + sg = &ctx->sg[0]; + if (is_encode(ses)) { + sg->ptr = cpu_to_caam64(caam_jr_dma_vtop(IV_ptr)); + sg->len = cpu_to_caam32(ses->iv.length); + length += ses->iv.length; + + sg++; + sg->ptr = cpu_to_caam64(src_start_addr + sym->auth.data.offset); + sg->len = cpu_to_caam32(sym->auth.data.length); + length += sym->auth.data.length; + /* last element*/ + sg->len |= cpu_to_caam32(SEC4_SG_LEN_FIN); + } else { + sg->ptr = cpu_to_caam64(caam_jr_dma_vtop(IV_ptr)); + sg->len = cpu_to_caam32(ses->iv.length); + length += ses->iv.length; + + sg++; + sg->ptr = cpu_to_caam64(src_start_addr + sym->auth.data.offset); + sg->len = cpu_to_caam32(sym->auth.data.length); + length += sym->auth.data.length; + + rte_memcpy(ctx->digest, sym->auth.digest.data, + ses->digest_length); + sg++; + sg->ptr = cpu_to_caam64(caam_jr_dma_vtop(ctx->digest)); + sg->len = cpu_to_caam32(ses->digest_length); + length += ses->digest_length; + /* last element*/ + sg->len |= cpu_to_caam32(SEC4_SG_LEN_FIN); + } + + SEC_JD_SET_IN_PTR(jobdescr, (uint64_t)caam_jr_dma_vtop(&ctx->sg[0]), 0, + length); + /* set sg bit */ + (jobdescr)->seq_in.command.word |= 0x01000000; + + /* output */ + sg = &ctx->sg[6]; + + sg->ptr = cpu_to_caam64(dst_start_addr + sym->cipher.data.offset); + sg->len = cpu_to_caam32(sym->cipher.data.length); + length = sym->cipher.data.length; + + if (is_encode(ses)) { + /* set auth output */ + sg++; + sg->ptr = cpu_to_caam64(sym->auth.digest.phys_addr); + sg->len = cpu_to_caam32(ses->digest_length); + length += ses->digest_length; + } + /* last element*/ + sg->len |= cpu_to_caam32(SEC4_SG_LEN_FIN); + + SEC_JD_SET_OUT_PTR(jobdescr, + (uint64_t)caam_jr_dma_vtop(&ctx->sg[6]), 0, length); + /* set sg bit */ + (jobdescr)->seq_out.command.word |= 0x01000000; + + /* Auth_only_len is set as 0 in descriptor and it is + * overwritten here in the jd which will update + * the DPOVRD reg. + */ + if (auth_only_len) + /* set sg bit */ + (jobdescr)->dpovrd = 0x80000000 | auth_only_len; + + return ctx; +} static int caam_jr_enqueue_op(struct rte_crypto_op *op, struct caam_jr_qp *qp) { @@ -629,12 +1232,25 @@ caam_jr_enqueue_op(struct rte_crypto_op *op, struct caam_jr_qp *qp) } if (rte_pktmbuf_is_contiguous(op->sym->m_src)) { - if (is_cipher_only(ses)) + if (is_auth_cipher(ses)) + ctx = build_cipher_auth(op, ses); + else if (is_aead(ses)) + goto err1; + else if (is_auth_only(ses)) + ctx = build_auth_only(op, ses); + else if (is_cipher_only(ses)) ctx = build_cipher_only(op, ses); } else { - if (is_cipher_only(ses)) + if (is_auth_cipher(ses)) + ctx = build_cipher_auth_sg(op, ses); + else if (is_aead(ses)) + goto err1; + else if (is_auth_only(ses)) + ctx = build_auth_only_sg(op, ses); + else if (is_cipher_only(ses)) ctx = build_cipher_only_sg(op, ses); } +err1: if (unlikely(!ctx)) { qp->tx_errs++; CAAM_JR_ERR("not supported sec op"); @@ -817,6 +1433,54 @@ caam_jr_cipher_init(struct rte_cryptodev *dev __rte_unused, return 0; } +static int +caam_jr_auth_init(struct rte_cryptodev *dev __rte_unused, + struct rte_crypto_sym_xform *xform, + struct caam_jr_session *session) +{ + session->auth_alg = xform->auth.algo; + session->auth_key.data = rte_zmalloc(NULL, xform->auth.key.length, + RTE_CACHE_LINE_SIZE); + if (session->auth_key.data == NULL && xform->auth.key.length > 0) { + CAAM_JR_ERR("No Memory for auth key\n"); + return -ENOMEM; + } + session->auth_key.length = xform->auth.key.length; + session->digest_length = xform->auth.digest_length; + + memcpy(session->auth_key.data, xform->auth.key.data, + xform->auth.key.length); + session->dir = (xform->auth.op == RTE_CRYPTO_AUTH_OP_GENERATE) ? + DIR_ENC : DIR_DEC; + + return 0; +} + +static int +caam_jr_aead_init(struct rte_cryptodev *dev __rte_unused, + struct rte_crypto_sym_xform *xform, + struct caam_jr_session *session) +{ + session->aead_alg = xform->aead.algo; + session->iv.length = xform->aead.iv.length; + session->iv.offset = xform->aead.iv.offset; + session->auth_only_len = xform->aead.aad_length; + session->aead_key.data = rte_zmalloc(NULL, xform->aead.key.length, + RTE_CACHE_LINE_SIZE); + if (session->aead_key.data == NULL && xform->aead.key.length > 0) { + CAAM_JR_ERR("No Memory for aead key\n"); + return -ENOMEM; + } + session->aead_key.length = xform->aead.key.length; + session->digest_length = xform->aead.digest_length; + + memcpy(session->aead_key.data, xform->aead.key.data, + xform->aead.key.length); + session->dir = (xform->aead.op == RTE_CRYPTO_AEAD_OP_ENCRYPT) ? + DIR_ENC : DIR_DEC; + + return 0; +} static int caam_jr_set_session_parameters(struct rte_cryptodev *dev, @@ -840,6 +1504,39 @@ caam_jr_set_session_parameters(struct rte_cryptodev *dev, session->auth_alg = RTE_CRYPTO_AUTH_NULL; caam_jr_cipher_init(dev, xform, session); + /* Authentication Only */ + } else if (xform->type == RTE_CRYPTO_SYM_XFORM_AUTH && + xform->next == NULL) { + session->cipher_alg = RTE_CRYPTO_CIPHER_NULL; + caam_jr_auth_init(dev, xform, session); + + /* Cipher then Authenticate */ + } else if (xform->type == RTE_CRYPTO_SYM_XFORM_CIPHER && + xform->next->type == RTE_CRYPTO_SYM_XFORM_AUTH) { + if (xform->cipher.op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) { + caam_jr_cipher_init(dev, xform, session); + caam_jr_auth_init(dev, xform->next, session); + } else { + CAAM_JR_ERR("Not supported: Auth then Cipher"); + goto err1; + } + + /* Authenticate then Cipher */ + } else if (xform->type == RTE_CRYPTO_SYM_XFORM_AUTH && + xform->next->type == RTE_CRYPTO_SYM_XFORM_CIPHER) { + if (xform->next->cipher.op == RTE_CRYPTO_CIPHER_OP_DECRYPT) { + caam_jr_auth_init(dev, xform, session); + caam_jr_cipher_init(dev, xform->next, session); + } else { + CAAM_JR_ERR("Not supported: Auth then Cipher"); + goto err1; + } + + /* AEAD operation for AES-GCM kind of Algorithms */ + } else if (xform->type == RTE_CRYPTO_SYM_XFORM_AEAD && + xform->next == NULL) { + caam_jr_aead_init(dev, xform, session); + } else { CAAM_JR_ERR("Invalid crypto type"); return -EINVAL; @@ -847,6 +1544,13 @@ caam_jr_set_session_parameters(struct rte_cryptodev *dev, session->ctx_pool = internals->ctx_pool; return 0; + +err1: + rte_free(session->cipher_key.data); + rte_free(session->auth_key.data); + memset(session, 0, sizeof(struct caam_jr_session)); + + return -EINVAL; } static int From patchwork Thu Sep 13 06:08:45 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Gagandeep Singh X-Patchwork-Id: 44645 X-Patchwork-Delegate: gakhil@marvell.com Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id E7D855F20; Thu, 13 Sep 2018 08:09:48 +0200 (CEST) Received: from EUR02-VE1-obe.outbound.protection.outlook.com (mail-eopbgr20068.outbound.protection.outlook.com [40.107.2.68]) by dpdk.org (Postfix) with ESMTP id 553795689 for ; Thu, 13 Sep 2018 08:09:39 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=mf2hgXfqBOHv0Vz5xEJ2Y8mdCwH3zrS0isayg5/uznM=; b=Jk9dAW8SgmvtTBZBZSluPvTNAuwAatSyXOyohOuJDFOpaAq65WG7b9cyJO9Kemps5O0+xdTo5ijJBuwHOs7Yih2n4mCSA+TVbMg1Jb0qweKuODu0JbF2ih5lyuYzbWbvG7yaXHwp4A34VcDDaWzoNTZ2+2ryxM2fwXXXUdbwLf8= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=G.Singh@nxp.com; Received: from Tophie.ap.freescale.net (14.142.187.166) by HE1PR04MB1529.eurprd04.prod.outlook.com (2a01:111:e400:59a8::19) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1143.15; Thu, 13 Sep 2018 06:09:36 +0000 From: Gagandeep Singh To: dev@dpdk.org, akhil.goyal@nxp.com Cc: Hemant Agrawal , Gagandeep Singh Date: Thu, 13 Sep 2018 11:38:45 +0530 Message-Id: <20180913060846.29930-10-g.singh@nxp.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20180913060846.29930-1-g.singh@nxp.com> References: <20180913060846.29930-1-g.singh@nxp.com> MIME-Version: 1.0 X-Originating-IP: [14.142.187.166] X-ClientProxiedBy: BM1PR01CA0095.INDPRD01.PROD.OUTLOOK.COM (2603:1096:b00::11) To HE1PR04MB1529.eurprd04.prod.outlook.com (2a01:111:e400:59a8::19) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: d6bcb79b-1a18-428b-f08e-08d6193f7c2a X-MS-Office365-Filtering-HT: Tenant X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989137)(4534165)(7168020)(4627221)(201703031133081)(201702281549075)(8990107)(5600074)(711020)(4618075)(2017052603328)(7153060)(7193020); SRVR:HE1PR04MB1529; X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 3:Lvk1v8br7sYU6MewVbMCMha6ASfmRyI5LeFFtOMLW3A9ZJ71yHBmwhUECHeiuHNGj248Lw4p0dWf8Rnm/0F1KVn4FNsORLbY+uwyURHWnqd/JanNfihrB09IEs2KfwY78OqxnPg+jCvYqN1Q80HNw4VolhZjJXg7Wdb3uUJ6NaxHRuzzMdQmC9hbmMlnBulx1kaFO7gzsRE8A2l4fs9HgO949GQoKAFxuCWP08NM/TyE39gWddytgLhNfc+1Aenk; 25:PzPH2In5KcU/ruc8fJ1HU4DGGsj1B7U8e1gLpVQeo46/IH6NWcQnvP32MCAVUdBqATa5zkgNs6mdmwunAtRJj+68LFTD4RmQcaaSeeG+VsGv6fEWOnQPY3q8hCXwyUqtCeHppUJtjY7p9hYISD9pIP/qrpQSaszu3atESOJh4QMDrD0T7nMu8TGBFhKH9Z9pyrtiriiwEYE27d2u4JdXOf6FbQ1Y5/nz62shOcWISr4RvJHDSacvd5J2h2UgM3dUB1kmfFp6qaxbbk+fKrMAqVWJkNauCNj6+PzIJHz15G9yC8UnisV9/7NgKoy+lo/YjZAzysk4QV44b9mpDschYA==; 31:tKq10tzrzAjouD/OmNrkazOEWq6iLoHxcq9ubipatcHbVxLahhaLwmsa3g4xqa7z1rXcA7StkTEbuI6I/+0EavWovqBR2Gj/BHQqF2NWqmUUpGe5GxghhEllId0phyvwsoW3a75oefz9I8bHQlUEY47bVHyhgBJxpV0RFt/s3JrYQ8ZCu85AbX8kfmtppD3BhInvnHNoYQOFqdlYcsQY84vlhsqJ3vLD4tpALN+3rlA= X-MS-TrafficTypeDiagnostic: HE1PR04MB1529: X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 20:kae4L6OXNGCAkgORjLs56vipcQf7I98koJvgi/RCYG4EvcF8C1xzXftE34++N2+VtvI7Iw3QOCFJKgTgpNgGdkICWn+FQAMgV+wOsv7C7wCCxuE9gPSKzaqQ/fsYY7q5hV7kI+1McdltufGwNYESvNhT8j4M4plpYmxlbAJGdE/Ehhoby4C6XFLfldAIx/p1U5hvWZkTUi9RmrCriVoC2CCfczu9XiefZTpjNfwo/pdZUfqyFW6rA4sSpXzCsuHYi3wGCae9oy7+E/ooOgtbH9d7Qd/EZ5q1HVJysQcw7/JPCCWzsMXIxgrLrVURmQcvRf5gmQzOvqBx19mikY2ofd7pFeF8gFID86/5VD1qP+ANIMbTN6m6O7ie3rAMiEilECcQZzup/lXtOokIYG7t8KFNFrAa2M5oCWQkz+4klYsQfhQapNgqgTsBkBO4/e4JsissUJzgorQVEYJjPp/8ysuAiWvyLFfHd+JaJ1TlL1CToxoXYzsWBCn5sTb3Q543; 4:pFDKPPAhAZvY/S3Z0Hmbrl/2m6FhCnL5nM3J6xtFxSZL+IefbvSiMP74tZlP36BUl+8SeHIQNT72pRpappi23XECZeraCZotdcl847X7Ex/KFsn6bQwE8U1NqnoStqcNVuWACZxjcIilCqTLKZOcMfdEAEM9NH4VGRt6woVfkCjdgVIIE2OGAC+TbuIXcsD0veqc1WtJjjymC+2OWTqDn5VGfYuyp0MCKJYwkKLpXMXNrf1JuRNd3IIPOyTaxzB0e2Puxny+5hORtqgt6AJoZDSjbp3ZFwR+vFVsafgCfkdPHyJZKJtzblbfb03NvbKD X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(185117386973197); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(5005006)(8121501046)(823301075)(3231311)(944501410)(52105095)(3002001)(93006095)(93001095)(10201501046)(6055026)(149027)(150027)(6041310)(20161123558120)(20161123562045)(20161123560045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123564045)(201708071742011)(7699050); SRVR:HE1PR04MB1529; BCL:0; PCL:0; RULEID:; SRVR:HE1PR04MB1529; X-Forefront-PRVS: 07943272E1 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(366004)(376002)(39860400002)(136003)(346002)(396003)(189003)(199004)(2906002)(6506007)(386003)(5009440100003)(6486002)(51416003)(6512007)(52116002)(486006)(2616005)(68736007)(956004)(53936002)(476003)(446003)(11346002)(305945005)(26005)(7736002)(55236004)(76176011)(186003)(16526019)(50226002)(478600001)(47776003)(1076002)(3846002)(6116002)(48376002)(105586002)(106356001)(25786009)(14444005)(50466002)(5660300001)(36756003)(72206003)(66066001)(316002)(97736004)(8936002)(81166006)(4326008)(8676002)(86362001)(6636002)(6666003)(54906003)(81156014)(16586007)(110426005); DIR:OUT; SFP:1101; SCL:1; SRVR:HE1PR04MB1529; H:Tophie.ap.freescale.net; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: nxp.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; HE1PR04MB1529; 23:4TfV8SINjLDJdlXE2fG7NqCJg8KcUMHcZ7e/3fWIM?= ej4JsXNoMrTQKKVteMviG20rqNG3XFFVZG7DzwyjHPIoX9HTWBijc16mioQ20tHonA2V+IiDH64UXFhCWQpMaDFFriwcNnKHHLD200A03dpB4nZAMtKhYiOthJNcSlFKO5JK7+Q6ShxRk1UsZtm8b6FEgOd5PYrr0OzXNIQC5encX5lWkf/Pfn74kTb50o6CrK/qX81aquDLlzYD52gWETfSk3JS0Fat7zWDi5F1G9nyrJDi9H9KnI7oHHILETh/dfM65pFyQLyit2NSX+g3qhc0l4usr7ZGJsFIAw+PGdm0+jwvpWNctqwhdjXQAy+Q+QXjJttyVhOszu4AYFvG3itMdoeY8SVgoK5Nnj2jo9SXN56uebdp7xXh9ndnz1GVk9ivdwtWKspQHpmHkdoTe5yDpdAs1oMsZSuDhjKDVzGiSYOqXnP3E/Z3jhTGMCLz2/QkJflwc08vQOOmNT1EC8g59qkZESNrgIHwcUzV+fxC8Emm1OvdOwluvj6VzCZTq3ZrX0NgGaAmkvd78RZNFRzAsbmNMDYgSb8XTb0DUTjpSN+YT8WfQbY4MUfQ3qIdb1Sk3jfzNA2nbNbyrfS4mTXvMnNCqifmUzkQYCf3JcjtBPttOmhi7RqZ51IU5wnZjvrz+DL2bfAb1H3Q+zIyj8eUNS9yFNhSu6FU7SlnNmGLZ6wOk5eS6V3/rSi84Hk/ypauAvmwlTPqEe8C/llAPYr4PbLbuv056jtXvYGqSPE9vQZ3Izf8mQ6GqbVUL1w8jCGkz2GXiiUiZFSV2PFpD4LSWoYBXYom0xlgqdkCPrUmCS4mDFTR6iZUGiAVZjNihjpNZrbODO+e5zwlmFkbs6ckD0RVOPVwoJFhP2+47ODVEGvfzxnkZJ8fNkVENhRoPSGlGPd5bcKrGbjpfEbCeXHLFArqb+oyRCKCkQeR9M12cvJx58dsOBzhyVtdKF8s8M08FbS2oYOmKOYWsucHoxqHLKgh+dCnuADd7DYao7QEFVQ2UQSk15mUeJH+ooZSoX+ZLJ1+rDCVIRI3S2DhQ2H8l+npNU65jbE1RorS3CpatJ5LjDP0nLbJ7c/PcHKG5Et7bKYbx++nw2qv798gMnMSdmfFWE+9lVAmC6BS864AGrm4ZM9ktM4MK+hKRB32d1BUnuVgzp6I8W+Q8tAhte8Lk5nETnRRtBxa2Ws23yLQUlX2tJuZr/5X9DylWEpmeVXHcDFGdiBlHYSiZCoB0Ka7ogDP6z04Ru7NhRsn0iJb95Qn2vQ26ywZAZqZe++7Na3HHGR/EDTKI0szhLak8CN X-Microsoft-Antispam-Message-Info: dpb0DjGd39cGyv1ylS0+OZ4+WrZ3AXnhc999ddBp6n0fLgsQrl177NwJa/cxoJ6Xp5eGctjp8mWIlNBXoKcukJqwLBJIf6Bhb6NfKPBhLLnGY5AjdoOx1B7by7p9RqNUO7EDJYwg4ByYdv7qWybFn/J1WsXHtIFQe2A0qqJDEgQ8IGw8yqnv8lgriMKAVWfv9O54ocTz1oiVO5PzrWE+ksgufS05Xkaxa66zhDvG6UmxtYVQQxJYq2+gBK9JG2+aYbMgePtrizK4lYwDaNVhGNY52JTuvK0A/My0py2ysfCh+mh709kHOlZ2A6qD6M86BZzD+UXAenBnUuv9+P0VXWl7g83TALeD0vk9K6IjwdI= X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 6:F8+ldf1Jx/rGpUU9CunNwoDlJNC3HZJnP5jBetXmeMYFhPtddzfvk9Ig2ie/FuDseWamLnRJtTwcs8QuSFl2gYNJkE+8OeidT8Q7kYMlK0eSHBlKR0INARVAcR1jKUg0Mj9YFHkTQChQvuK78hluPratcuPOFg1KuiN/TmQc2zQ5EuQLtrws3rBRN07c4UnEsIiKRL3t+BrxazXyHsPq8D0yGdijhfxec2ZzhuWtX1PuXdnSdvu5iF8hZmCwsdjx0XJhX43SB1qXcXLHOi0mG4IZwtiu0me99MC3jkdWXCGv9X83H0+taXWgEeDeRryGg+VVisQmOefVgnFrT3sUx+pEjEXMoRj/q1Ppi6GnROeYHp2gCFCmOk8tdHcOwEPdNeXhVl6xr96QFtlkdmOx8maLYPbNzC572roRjauyNLpi3WrQGMQ0q1pcKNO1pXymfFSRyrqDrakwfbV/wLlc9A==; 5:+0su8s2CmtbWULVsiQ0KSSdqrkCSLjDpStbJWQ/CSwNhBGQO3ovgFwJR718WES2sWraECpigGKzhnIVhvugmA7yf6LP9G6/Gbq4I+SwC7V48TwntixtuUZeud3WwWxEQpzdiZZl375yg44khiT6xHkheUAyMVTDcgjo1yryxOlQ=; 7:FlUDJiQQTZvkc2/qSLwMKVSngP+rjPZvPZ1jFkaDB+VNFWaxFbg1+VHM7gqQBldP4LPwbfqAozQXxrXIkjmnBW3nQhLSzBkdBh5koTpNqU+xSRjV4ZQ+24woQNZrvOKV9oIqxMvzbqpf9Ma47cPLGfkcbSGQ8V6r11XhVFshD4pWVvSHHv9qcvWZYnb+0nicorPkVHv9gKZVoc3RKQC5VgcRb0U5Hz23cx/XN5XcRgWWcg4cGT5c29TTEiTQnNP1 SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 13 Sep 2018 06:09:36.4451 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: d6bcb79b-1a18-428b-f08e-08d6193f7c2a X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-Transport-CrossTenantHeadersStamped: HE1PR04MB1529 Subject: [dpdk-dev] [PATCH 09/10] crypto/caam_jr: add stats 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: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Hemant Agrawal Signed-off-by: Gagandeep Singh Signed-off-by: Hemant Agrawal --- drivers/crypto/caam_jr/caam_jr.c | 55 ++++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+) diff --git a/drivers/crypto/caam_jr/caam_jr.c b/drivers/crypto/caam_jr/caam_jr.c index d582b2fcb..f51ff1093 100644 --- a/drivers/crypto/caam_jr/caam_jr.c +++ b/drivers/crypto/caam_jr/caam_jr.c @@ -99,6 +99,59 @@ caam_jr_alloc_ctx(struct caam_jr_session *ses) return ctx; } + +static +void caam_jr_stats_get(struct rte_cryptodev *dev, + struct rte_cryptodev_stats *stats) +{ + struct caam_jr_qp **qp = (struct caam_jr_qp **) + dev->data->queue_pairs; + int i; + + PMD_INIT_FUNC_TRACE(); + if (stats == NULL) { + CAAM_JR_ERR("Invalid stats ptr NULL"); + return; + } + for (i = 0; i < dev->data->nb_queue_pairs; i++) { + if (qp[i] == NULL) { + CAAM_JR_WARN("Uninitialised queue pair"); + continue; + } + + stats->enqueued_count += qp[i]->tx_pkts; + stats->dequeued_count += qp[i]->rx_pkts; + stats->enqueue_err_count += qp[i]->tx_errs; + stats->dequeue_err_count += qp[i]->rx_errs; + CAAM_JR_INFO("extra stats:\n\tRX Poll ERR = %" PRIu64 + "\n\tTX Ring Full = %" PRIu64, + qp[i]->rx_poll_err, + qp[i]->tx_ring_full); + } +} + +static +void caam_jr_stats_reset(struct rte_cryptodev *dev) +{ + int i; + struct caam_jr_qp **qp = (struct caam_jr_qp **) + (dev->data->queue_pairs); + + PMD_INIT_FUNC_TRACE(); + for (i = 0; i < dev->data->nb_queue_pairs; i++) { + if (qp[i] == NULL) { + CAAM_JR_WARN("Uninitialised queue pair"); + continue; + } + qp[i]->rx_pkts = 0; + qp[i]->rx_errs = 0; + qp[i]->rx_poll_err = 0; + qp[i]->tx_pkts = 0; + qp[i]->tx_errs = 0; + qp[i]->tx_ring_full = 0; + } +} + static inline int is_cipher_only(struct caam_jr_session *ses) { return ((ses->cipher_alg != RTE_CRYPTO_CIPHER_NULL) && @@ -1689,6 +1742,8 @@ static struct rte_cryptodev_ops caam_jr_ops = { .dev_stop = caam_jr_dev_stop, .dev_close = caam_jr_dev_close, .dev_infos_get = caam_jr_dev_infos_get, + .stats_get = caam_jr_stats_get, + .stats_reset = caam_jr_stats_reset, .queue_pair_setup = caam_jr_queue_pair_setup, .queue_pair_release = caam_jr_queue_pair_release, .queue_pair_count = caam_jr_queue_pair_count, From patchwork Thu Sep 13 06:08:46 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Gagandeep Singh X-Patchwork-Id: 44646 X-Patchwork-Delegate: gakhil@marvell.com Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 9E11D5F2C; Thu, 13 Sep 2018 08:09:50 +0200 (CEST) Received: from EUR02-VE1-obe.outbound.protection.outlook.com (mail-eopbgr20069.outbound.protection.outlook.com [40.107.2.69]) by dpdk.org (Postfix) with ESMTP id 1B73958F6 for ; Thu, 13 Sep 2018 08:09:41 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=35+otj37A8ViFD1n+dIZBlaPwv1d6hsCiGfq4vxP20M=; b=dlo07dmh7gjhXzYPNj7XO75tO2nCHxn2d+PbgOx5JHwpdzUUGt3/cThWgZShbWYAhLT6CQfCEkS7Bf+DbKZx0ndupsoW044mXvoJ9BYrR/F4bl63LwCiU14Xh6hk3a924qe8j7iH4HZvWNN8+ycmJPEqbpZB5s4zPS/z4cDXsGY= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=G.Singh@nxp.com; Received: from Tophie.ap.freescale.net (14.142.187.166) by HE1PR04MB1529.eurprd04.prod.outlook.com (2a01:111:e400:59a8::19) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1143.15; Thu, 13 Sep 2018 06:09:38 +0000 From: Gagandeep Singh To: dev@dpdk.org, akhil.goyal@nxp.com Cc: Hemant Agrawal Date: Thu, 13 Sep 2018 11:38:46 +0530 Message-Id: <20180913060846.29930-11-g.singh@nxp.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20180913060846.29930-1-g.singh@nxp.com> References: <20180913060846.29930-1-g.singh@nxp.com> MIME-Version: 1.0 X-Originating-IP: [14.142.187.166] X-ClientProxiedBy: BM1PR01CA0095.INDPRD01.PROD.OUTLOOK.COM (2603:1096:b00::11) To HE1PR04MB1529.eurprd04.prod.outlook.com (2a01:111:e400:59a8::19) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: ff805c9f-ed0c-478c-4bc4-08d6193f7d06 X-MS-Office365-Filtering-HT: Tenant X-Microsoft-Antispam: BCL:0; PCL:0; RULEID:(7020095)(4652040)(8989137)(4534165)(7168020)(4627221)(201703031133081)(201702281549075)(8990107)(5600074)(711020)(4618075)(2017052603328)(7153060)(7193020); SRVR:HE1PR04MB1529; X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 3:Jv+R+Kj2SK1T7E5jSfmY1FfCh5dnlSVm3lewZgBz8qHluKPcgVD/esjckoW0ljzQzrA7NuDn93bNnz152kLn97wU7THdltgpdt23uwkuE29sxbNDwzaJJVsCDXvFHgXaWGHydHkPe8CmO50GPd8FPK02c3ghoxXvTTgWC9a0jGd/neqqIHlAcGaFmHZYedqVbZAYR5iGFgXI0YigSsW4v+RuHjpXBHaf9vQukLbuB630hgEHyVloW9IlfYSBrR3/; 25:6+NJdSO/naom6l3AsvYtci0eMqA9IgdBQNTy4F85pQlIuYkR4NCdsFnX01y/uFiq8iHcTvOED6uS9zQzKHPDXe+cSpBLyrUjOv52qzC2AfwwaV2JUVGY5abXAkenjbG3xIg5A8koHKN8jNMssgssQwSfW1JeDLFYBcc8zLmwg70csxxPhbbw/krp4AR162lmWTY+hsMLUX46xPpCMboqfvt0lEfhq/azbMn+yLltxcSYhXEfuJTjHYZJPDXhd0Xlr3pT4QrT3/6ReEMjpDWT7PDNUOk/0mM4dmU9Lc1hfDEBKHS23ndG5+SuCojpe6LzzQGSGerEsCEGdYBOdonxwQ==; 31:cOndFLsTDrgkWplA+7EGLdKbQDJiWLoUQGtGw0kpIeexJwtyALUlYbdmerzWajp7ORrJXDTJH1eDSKZbM0r4x9/AtPxehOAMzRSZVfaLrroQwp+WwJ8J916SghIcPSvPKKsGeboQ+pgL0Dn/cxCFa92XS4r1yEaW1sDt74XNDPubSJrGqVavG4diXYdnksWvsAq7oasx2dnnK+rtA0hjNPaHwNhXlsWBSVVNQyTMW3o= X-MS-TrafficTypeDiagnostic: HE1PR04MB1529: X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 20:ECSS4GILo7UUW8zdzdj1FtGlCplt4ByeARbhraa8WcV9CpSrzEOgRj9t46K9hkTbwahhA5GkIEUTa4qJjXvluVfL5+JJRRRyd6gHgGpgJrO9fP1Wh5dqdj9F0R1F8K4ylHALihYN2hJgGCiGHG+ydepYVhEnIvfW/5U79hcF3LR8YIlPXNdT0+S2MiPHAdWxx7TV9X3iB4auWFUeLxnJhFtt/2TlqPSk3x7mNNgciCrWmPmxLilz86DfPta6JC8/DG/ub2t+T6MmiAwi/2KmzqqWKlsu+drm1nLKFQt6ZISP8OtGKB5fdGRSlWPeLxgoAjxo2Ozr3ztpR6YcBPCMLGg1EkDdj44mYjmcxKIBonzyXVNKvRv47nOiXKs2ndcMXVjcLR9g2fs/EzswPa3XqC5D131OkQWem+76aVTkhsWPBPsyJlkYSPuW/+7qdLBalX4ASEK24b+8idR8Le1R1u9HPMVnq/QKK80kmq0tcXtPJclkGedMGf9Gqme81ktT; 4:+ZZ4C2T15SFApFUbkkCglnTZlBY0aK9iHF5vTjY+BEcm21XpIMvHGMk5d0HL2ze90oSMprNvEY6azPKtBEdNOPjH57h8tGaYm9siaF7TuB9LxAQtwaee3PsJWGRQS4OS5c75FQ+2numuphbuan5yAisWTlEIvaNk19F5VPWxHyudB+SOpibLcfugoL2l05r/XUQsS+lMa2ouYfE/PRRGSj6fsPQ69HnI3ZWpHYD3wDEQ/ohRyl/XcdGPVPumKrSW0lqMQ6H6RvV15vbY3JrtmgfgaPFUf/vV2EbYwxZaOCuam16U6yR7XSbHhOEEoJog3Ikg0XbQ1HgBysFpq+MFE8T2G3MHoDxo8DiV7Jz8Nco= X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(192374486261705)(185117386973197); X-MS-Exchange-SenderADCheck: 1 X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(5005006)(8121501046)(823301075)(3231311)(944501410)(52105095)(3002001)(93006095)(93001095)(10201501046)(6055026)(149027)(150027)(6041310)(20161123558120)(20161123562045)(20161123560045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123564045)(201708071742011)(7699050); SRVR:HE1PR04MB1529; BCL:0; PCL:0; RULEID:; SRVR:HE1PR04MB1529; X-Forefront-PRVS: 07943272E1 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(366004)(376002)(39860400002)(136003)(346002)(396003)(189003)(199004)(2906002)(6506007)(386003)(5009440100003)(6486002)(51416003)(6512007)(52116002)(486006)(2616005)(68736007)(956004)(53936002)(476003)(446003)(11346002)(305945005)(26005)(7736002)(55236004)(76176011)(186003)(16526019)(15650500001)(50226002)(478600001)(47776003)(1076002)(3846002)(6116002)(48376002)(105586002)(106356001)(25786009)(14444005)(50466002)(5660300001)(36756003)(72206003)(66066001)(316002)(97736004)(8936002)(81166006)(4326008)(8676002)(86362001)(6636002)(6666003)(575784001)(81156014)(16586007)(110426005); DIR:OUT; SFP:1101; SCL:1; SRVR:HE1PR04MB1529; H:Tophie.ap.freescale.net; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: nxp.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; HE1PR04MB1529; 23:KOJHRc8O4tNUfYhOgXRNEHWhX0HFmAHD+yX0yscvb?= adb8Jj3ZRcI/WUjV4t8EBSHSN/07Zrzn3nTWs2YzFDCIGwUrIhmR16HTCiFIoietzFba7Bt3TvlIIenXw25L1LqQNfvx5Z1AMIRoic7hncxHIUf6AYSHmFpRw+qPcxKRlEVbqbFeyt5SLY1xrJGqndAGzMHpjOTGHn3O/5pbaPQI97dF0uQnNGmQt0lIUAF0aECo3tUOuDvqmLbqS1FLGOuFHLg3aPjYAvL+D0k1h3Wbg0f/VvTeCdMIc4bm9PBTtuBA3zuGsxhb7aY+ta3ui5IgKfr1ooTUSTCz+B0PaCkJ47gEjeXvtbbFa25C74l3gx9ohOHLLemztWE7zCadKgmxH1HYDZwsoyZ9j+6cVs/ZxiTLbfekEONfRZ+FFceIA9O4peVMB+lGdfA10r0WciydvZKD7jtomE2Zk2WnR80RRTlBtkbxJ71Sp50zFk8GkSxFg0fWVEj6AghLx//cxZoQ1SwG6iXJc7boDZdeWQc/FGlQclRGMt6oVQtFeGmU5sjluXUzBy2vEkqk/byXCsKFHcPrS1Ot3Wj5ruA0KsBUUm8f5YqxTPiZl3rGeIYpd2zmQay1cGIz4qfsl++IIkcyjt8i1NDnvjQBvE+wLt73SNrgOkj3CAOHm0vXFIZC13d+rgEMm3MlnftB0gZ1QKzZkdmiRMV9EC/0iPfWzCz7uKXm0kkRvFQxr5LzRfh3nOmmLwfZg81QOgpYbVUheTtqjWE08W77E232w5UDwTSRQO0Omgeuj71Hq1VBhoNXCOyQxJIGPN1dcTOq22luHVQG6pwg/OUSz8v9qbNw5qEntK/6CF99j6byk8K2YxYD8oWpTq/Vc93ip6czngsd9qwlxpGsT33PYBb5UIUgFkMEIbRE2HBbso7tNzlbPa626Px3B11PJamGydwalKUcQnTfe0ld0hoa1rRVIIWshZ/jl38Ncrse2/eG/QKnDnKS5vXR8fWsYlsFV9dukJNltDf23oyCaY1qg2le9EplgxrjDq3YSYWwQgDSkQi8SCKLPXGjZ9YRAq9JjEUBVHXRUTpYMX7+Zpo1uKzMfBSkVHA4xDVEhXrcmvNFc3TW7BvKtA8QHVw3rFIIfpivjxsd2b/Xb+Hd9iTyBkbpmoEADqb6Rogr9oqT1fqJU3ZWQokWZnS8o/zx711XvXPNH+tMFeGbgAFYeQrlIAypPvDJ++304Hwr3qqDaZ+lSsYWKXUfiHj6J5MuN+nk+Exfbo0F+6IFFg7Wv4c9N08pw/vgDlklDkcZfPALYnP4Miw1tV9BIahGCrfGl105DvmRwnTkf6bHShOnoDneYUOdE0khavJcA== X-Microsoft-Antispam-Message-Info: TdXwPe/74BdWhlrkapDAxVFbHp4vKSGdgUyFp4ya2gyHHzYTEOLjjx8jd2h5RUV73hBj5YfDXFWMHeq3dpc9fyU2D3Pi3FNGk8P84Owhm44qXdS3hpQHVbw3mY6KgxKwNMC7oPS/7OH17He7uVkaT3a7CtW8v1lsksORrSFh9ubWXotdDhDsLJSxD1wtwHZbKF5vvr3rZTj8xD0BHs2mcELZ5LDf8goyVBxjMy4GhJnM8yNVz2iA8xprPbQlhzQ9GfDUsTriRCFWw82+3I7Et/4wZhUyN97FskvFjMZ7Raom3++TwwTjGZI+QrTdgRrAsvHtv6Itzt725iVf1ryqmqg3KCyeNumCJjDhQAmTX2U= X-Microsoft-Exchange-Diagnostics: 1; HE1PR04MB1529; 6:ROxmv89cAe3xU7GyqOqWzeyhbd+TfNptzrNJXnCXLD32X6OPh7IMgW/4PkA4nRomrJAoUlET5jJRPyRdQKhTwaofv0crglT7AtAnTiz29sMYSSDL6q25uOOfi19bB+8xZJYkXW/31VZ3jpuwfxCFTlpdok95XPLMEVkYvgrzU0ahMQuMYXni/P7kajgVPirUUacjxdppANPrpTW4nW6MvO7gkvA3uAcF0Y6xdBW6RjqB2cX0t6ebHXQ8Fg+Hic25foPRcN9t4xXgvYR8RTpUB7fbY6b8uNYYmJeUWazPGOeOxXC4NWUoQZnMjH97mxpGNYK2vLvDlMQO8swXZ4cpBUsOtGMiQJD/huBZYiFxkyUnkA7t/AGlbiGAnruKWxJUCs3d7/ut3udIB5Pz72X9axAcZcg6LFpxPPSz3Ukup9GW8oWH6KGOtGj1jFbSxz7WKawkLsfkAf8iAFEqiJhiig==; 5:GNHFZv0PJ0GclADNHLAFkQjJjKKazri8EDgHLvFpmaDCBvxj2hJQxRifJUgeM+yjPpt2GlXyiE+yOqU87tQheYBPdAR6ihdJGgoybuIo41lzQ0fqhSQT7qx+CgO9kOw81WIAgZTz5hudhAW85J5DEBcb0w3EC/3ikmifjImgZ2U=; 7:E3l7zmdRkcoMwkj6q/aseZPd340IJ2RRUh7TEa/3YlMejToxKU8+NN1fNWNaEix1fNXGf+FezLO7WzEtYFioh7dOtrVkFz4mTj5KbMRqNEz3wfQj2JJwDk9wFUsYrldyNiIPK0PF4+wN3N6yzSxuI3lByu4wZSqaJ4ggaCN5H5Y6T92xuQ0NWbS7GSna9NKowKptMDk0GlIMXeb0TwS0/c9WKtj3BRpfXJSPAhEER78QaOIaTDM/uznVrzy+lPW2 SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 13 Sep 2018 06:09:38.0702 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: ff805c9f-ed0c-478c-4bc4-08d6193f7d06 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-Transport-CrossTenantHeadersStamped: HE1PR04MB1529 Subject: [dpdk-dev] [PATCH 10/10] crypto/caam_jr: add security offload 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: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Hemant Agrawal Signed-off-by: Hemant Agrawal --- drivers/crypto/caam_jr/caam_jr.c | 361 ++++++++++++++++++++++++++- drivers/crypto/caam_jr/caam_jr_pvt.h | 3 + 2 files changed, 354 insertions(+), 10 deletions(-) diff --git a/drivers/crypto/caam_jr/caam_jr.c b/drivers/crypto/caam_jr/caam_jr.c index f51ff1093..c4689078a 100644 --- a/drivers/crypto/caam_jr/caam_jr.c +++ b/drivers/crypto/caam_jr/caam_jr.c @@ -174,7 +174,13 @@ static inline int is_aead(struct caam_jr_session *ses) static inline int is_auth_cipher(struct caam_jr_session *ses) { return ((ses->cipher_alg != RTE_CRYPTO_CIPHER_NULL) && - (ses->auth_alg != RTE_CRYPTO_AUTH_NULL)); + (ses->auth_alg != RTE_CRYPTO_AUTH_NULL) && + (ses->proto_alg != RTE_SECURITY_PROTOCOL_IPSEC)); +} + +static inline int is_proto_ipsec(struct caam_jr_session *ses) +{ + return (ses->proto_alg == RTE_SECURITY_PROTOCOL_IPSEC); } static inline int is_encode(struct caam_jr_session *ses) @@ -195,27 +201,39 @@ caam_auth_alg(struct caam_jr_session *ses, struct alginfo *alginfo_a) ses->digest_length = 0; break; case RTE_CRYPTO_AUTH_MD5_HMAC: - alginfo_a->algtype = OP_ALG_ALGSEL_MD5; + alginfo_a->algtype = + (ses->proto_alg == RTE_SECURITY_PROTOCOL_IPSEC) ? + OP_PCL_IPSEC_HMAC_MD5_96 : OP_ALG_ALGSEL_MD5; alginfo_a->algmode = OP_ALG_AAI_HMAC; break; case RTE_CRYPTO_AUTH_SHA1_HMAC: - alginfo_a->algtype = OP_ALG_ALGSEL_SHA1; + alginfo_a->algtype = + (ses->proto_alg == RTE_SECURITY_PROTOCOL_IPSEC) ? + OP_PCL_IPSEC_HMAC_SHA1_96 : OP_ALG_ALGSEL_SHA1; alginfo_a->algmode = OP_ALG_AAI_HMAC; break; case RTE_CRYPTO_AUTH_SHA224_HMAC: - alginfo_a->algtype = OP_ALG_ALGSEL_SHA224; + alginfo_a->algtype = + (ses->proto_alg == RTE_SECURITY_PROTOCOL_IPSEC) ? + OP_PCL_IPSEC_HMAC_SHA1_160 : OP_ALG_ALGSEL_SHA224; alginfo_a->algmode = OP_ALG_AAI_HMAC; break; case RTE_CRYPTO_AUTH_SHA256_HMAC: - alginfo_a->algtype = OP_ALG_ALGSEL_SHA256; + alginfo_a->algtype = + (ses->proto_alg == RTE_SECURITY_PROTOCOL_IPSEC) ? + OP_PCL_IPSEC_HMAC_SHA2_256_128 : OP_ALG_ALGSEL_SHA256; alginfo_a->algmode = OP_ALG_AAI_HMAC; break; case RTE_CRYPTO_AUTH_SHA384_HMAC: - alginfo_a->algtype = OP_ALG_ALGSEL_SHA384; + alginfo_a->algtype = + (ses->proto_alg == RTE_SECURITY_PROTOCOL_IPSEC) ? + OP_PCL_IPSEC_HMAC_SHA2_384_192 : OP_ALG_ALGSEL_SHA384; alginfo_a->algmode = OP_ALG_AAI_HMAC; break; case RTE_CRYPTO_AUTH_SHA512_HMAC: - alginfo_a->algtype = OP_ALG_ALGSEL_SHA512; + alginfo_a->algtype = + (ses->proto_alg == RTE_SECURITY_PROTOCOL_IPSEC) ? + OP_PCL_IPSEC_HMAC_SHA2_512_256 : OP_ALG_ALGSEL_SHA512; alginfo_a->algmode = OP_ALG_AAI_HMAC; break; default: @@ -230,15 +248,21 @@ caam_cipher_alg(struct caam_jr_session *ses, struct alginfo *alginfo_c) case RTE_CRYPTO_CIPHER_NULL: break; case RTE_CRYPTO_CIPHER_AES_CBC: - alginfo_c->algtype = OP_ALG_ALGSEL_AES; + alginfo_c->algtype = + (ses->proto_alg == RTE_SECURITY_PROTOCOL_IPSEC) ? + OP_PCL_IPSEC_AES_CBC : OP_ALG_ALGSEL_AES; alginfo_c->algmode = OP_ALG_AAI_CBC; break; case RTE_CRYPTO_CIPHER_3DES_CBC: - alginfo_c->algtype = OP_ALG_ALGSEL_3DES; + alginfo_c->algtype = + (ses->proto_alg == RTE_SECURITY_PROTOCOL_IPSEC) ? + OP_PCL_IPSEC_3DES : OP_ALG_ALGSEL_3DES; alginfo_c->algmode = OP_ALG_AAI_CBC; break; case RTE_CRYPTO_CIPHER_AES_CTR: - alginfo_c->algtype = OP_ALG_ALGSEL_AES; + alginfo_c->algtype = + (ses->proto_alg == RTE_SECURITY_PROTOCOL_IPSEC) ? + OP_PCL_IPSEC_AES_CTR : OP_ALG_ALGSEL_AES; alginfo_c->algmode = OP_ALG_AAI_CTR; break; default: @@ -400,6 +424,22 @@ caam_jr_prep_cdb(struct caam_jr_session *ses) cdb->sh_desc[0] = 0; cdb->sh_desc[1] = 0; cdb->sh_desc[2] = 0; + if (is_proto_ipsec(ses)) { + if (ses->dir == DIR_ENC) { + shared_desc_len = cnstr_shdsc_ipsec_new_encap( + cdb->sh_desc, + true, swap, SHR_SERIAL, + &ses->encap_pdb, + (uint8_t *)&ses->ip4_hdr, + &alginfo_c, &alginfo_a); + } else if (ses->dir == DIR_DEC) { + shared_desc_len = cnstr_shdsc_ipsec_new_decap( + cdb->sh_desc, + true, swap, SHR_SERIAL, + &ses->decap_pdb, + &alginfo_c, &alginfo_a); + } + } else { /* Auth_only_len is set as 0 here and it will be * overwritten in fd for each packet. */ @@ -407,6 +447,7 @@ caam_jr_prep_cdb(struct caam_jr_session *ses) true, swap, &alginfo_c, &alginfo_a, ses->iv.length, 0, ses->digest_length, ses->dir); + } } if (shared_desc_len < 0) { @@ -1258,6 +1299,49 @@ build_cipher_auth(struct rte_crypto_op *op, struct caam_jr_session *ses) return ctx; } + +static inline struct caam_jr_op_ctx * +build_proto(struct rte_crypto_op *op, struct caam_jr_session *ses) +{ + struct rte_crypto_sym_op *sym = op->sym; + struct caam_jr_op_ctx *ctx = NULL; + phys_addr_t src_start_addr, dst_start_addr; + struct sec_cdb *cdb; + uint64_t sdesc_offset; + struct sec_job_descriptor_t *jobdescr; + + ctx = caam_jr_alloc_ctx(ses); + if (!ctx) + return NULL; + ctx->op = op; + + src_start_addr = rte_pktmbuf_iova(sym->m_src); + if (sym->m_dst) + dst_start_addr = rte_pktmbuf_iova(sym->m_dst); + else + dst_start_addr = src_start_addr; + + cdb = ses->cdb; + sdesc_offset = (size_t) ((char *)&cdb->sh_desc - (char *)cdb); + + jobdescr = (struct sec_job_descriptor_t *) ctx->jobdes.desc; + + SEC_JD_INIT(jobdescr); + SEC_JD_SET_SD(jobdescr, + (phys_addr_t)(caam_jr_dma_vtop(cdb)) + sdesc_offset, + cdb->sh_hdr.hi.field.idlen); + + /* output */ + SEC_JD_SET_OUT_PTR(jobdescr, (uint64_t)dst_start_addr, 0, + sym->m_src->buf_len - sym->m_src->data_off); + /* input */ + SEC_JD_SET_IN_PTR(jobdescr, (uint64_t)src_start_addr, 0, + sym->m_src->pkt_len); + sym->m_src->packet_type &= ~RTE_PTYPE_L4_MASK; + + return ctx; +} + static int caam_jr_enqueue_op(struct rte_crypto_op *op, struct caam_jr_qp *qp) { @@ -1272,6 +1356,11 @@ caam_jr_enqueue_op(struct rte_crypto_op *op, struct caam_jr_qp *qp) get_sym_session_private_data(op->sym->session, cryptodev_driver_id); break; + case RTE_CRYPTO_OP_SECURITY_SESSION: + ses = (struct caam_jr_session *) + get_sec_session_private_data( + op->sym->sec_session); + break; default: CAAM_JR_DP_ERR("sessionless crypto op not supported"); qp->tx_errs++; @@ -1293,6 +1382,8 @@ caam_jr_enqueue_op(struct rte_crypto_op *op, struct caam_jr_qp *qp) ctx = build_auth_only(op, ses); else if (is_cipher_only(ses)) ctx = build_cipher_only(op, ses); + else if (is_proto_ipsec(ses)) + ctx = build_proto(op, ses); } else { if (is_auth_cipher(ses)) ctx = build_cipher_auth_sg(op, ses); @@ -1661,6 +1752,227 @@ caam_jr_sym_session_clear(struct rte_cryptodev *dev, } } +static int +caam_jr_set_ipsec_session(__rte_unused struct rte_cryptodev *dev, + struct rte_security_session_conf *conf, + void *sess) +{ + struct sec_job_ring_t *internals = dev->data->dev_private; + struct rte_security_ipsec_xform *ipsec_xform = &conf->ipsec; + struct rte_crypto_auth_xform *auth_xform; + struct rte_crypto_cipher_xform *cipher_xform; + struct caam_jr_session *session = (struct caam_jr_session *)sess; + + PMD_INIT_FUNC_TRACE(); + + if (ipsec_xform->direction == RTE_SECURITY_IPSEC_SA_DIR_EGRESS) { + cipher_xform = &conf->crypto_xform->cipher; + auth_xform = &conf->crypto_xform->next->auth; + } else { + auth_xform = &conf->crypto_xform->auth; + cipher_xform = &conf->crypto_xform->next->cipher; + } + session->proto_alg = conf->protocol; + session->cipher_key.data = rte_zmalloc(NULL, + cipher_xform->key.length, + RTE_CACHE_LINE_SIZE); + if (session->cipher_key.data == NULL && + cipher_xform->key.length > 0) { + CAAM_JR_ERR("No Memory for cipher key\n"); + return -ENOMEM; + } + + session->cipher_key.length = cipher_xform->key.length; + session->auth_key.data = rte_zmalloc(NULL, + auth_xform->key.length, + RTE_CACHE_LINE_SIZE); + if (session->auth_key.data == NULL && + auth_xform->key.length > 0) { + CAAM_JR_ERR("No Memory for auth key\n"); + rte_free(session->cipher_key.data); + return -ENOMEM; + } + session->auth_key.length = auth_xform->key.length; + memcpy(session->cipher_key.data, cipher_xform->key.data, + cipher_xform->key.length); + memcpy(session->auth_key.data, auth_xform->key.data, + auth_xform->key.length); + + switch (auth_xform->algo) { + case RTE_CRYPTO_AUTH_SHA1_HMAC: + session->auth_alg = RTE_CRYPTO_AUTH_SHA1_HMAC; + break; + case RTE_CRYPTO_AUTH_MD5_HMAC: + session->auth_alg = RTE_CRYPTO_AUTH_MD5_HMAC; + break; + case RTE_CRYPTO_AUTH_SHA256_HMAC: + session->auth_alg = RTE_CRYPTO_AUTH_SHA256_HMAC; + break; + case RTE_CRYPTO_AUTH_SHA384_HMAC: + session->auth_alg = RTE_CRYPTO_AUTH_SHA384_HMAC; + break; + case RTE_CRYPTO_AUTH_SHA512_HMAC: + session->auth_alg = RTE_CRYPTO_AUTH_SHA512_HMAC; + break; + case RTE_CRYPTO_AUTH_AES_CMAC: + session->auth_alg = RTE_CRYPTO_AUTH_AES_CMAC; + break; + case RTE_CRYPTO_AUTH_NULL: + session->auth_alg = RTE_CRYPTO_AUTH_NULL; + break; + case RTE_CRYPTO_AUTH_SHA224_HMAC: + case RTE_CRYPTO_AUTH_AES_XCBC_MAC: + case RTE_CRYPTO_AUTH_SNOW3G_UIA2: + case RTE_CRYPTO_AUTH_SHA1: + case RTE_CRYPTO_AUTH_SHA256: + case RTE_CRYPTO_AUTH_SHA512: + case RTE_CRYPTO_AUTH_SHA224: + case RTE_CRYPTO_AUTH_SHA384: + case RTE_CRYPTO_AUTH_MD5: + case RTE_CRYPTO_AUTH_AES_GMAC: + case RTE_CRYPTO_AUTH_KASUMI_F9: + case RTE_CRYPTO_AUTH_AES_CBC_MAC: + case RTE_CRYPTO_AUTH_ZUC_EIA3: + CAAM_JR_ERR("Crypto: Unsupported auth alg %u\n", + auth_xform->algo); + goto out; + default: + CAAM_JR_ERR("Crypto: Undefined Auth specified %u\n", + auth_xform->algo); + goto out; + } + + switch (cipher_xform->algo) { + case RTE_CRYPTO_CIPHER_AES_CBC: + session->cipher_alg = RTE_CRYPTO_CIPHER_AES_CBC; + break; + case RTE_CRYPTO_CIPHER_3DES_CBC: + session->cipher_alg = RTE_CRYPTO_CIPHER_3DES_CBC; + break; + case RTE_CRYPTO_CIPHER_AES_CTR: + session->cipher_alg = RTE_CRYPTO_CIPHER_AES_CTR; + break; + case RTE_CRYPTO_CIPHER_NULL: + case RTE_CRYPTO_CIPHER_SNOW3G_UEA2: + case RTE_CRYPTO_CIPHER_3DES_ECB: + case RTE_CRYPTO_CIPHER_AES_ECB: + case RTE_CRYPTO_CIPHER_KASUMI_F8: + CAAM_JR_ERR("Crypto: Unsupported Cipher alg %u\n", + cipher_xform->algo); + goto out; + default: + CAAM_JR_ERR("Crypto: Undefined Cipher specified %u\n", + cipher_xform->algo); + goto out; + } + + if (ipsec_xform->direction == RTE_SECURITY_IPSEC_SA_DIR_EGRESS) { + memset(&session->encap_pdb, 0, sizeof(struct ipsec_encap_pdb) + + sizeof(session->ip4_hdr)); + session->ip4_hdr.ip_v = IPVERSION; + session->ip4_hdr.ip_hl = 5; + session->ip4_hdr.ip_len = rte_cpu_to_be_16( + sizeof(session->ip4_hdr)); + session->ip4_hdr.ip_tos = ipsec_xform->tunnel.ipv4.dscp; + session->ip4_hdr.ip_id = 0; + session->ip4_hdr.ip_off = 0; + session->ip4_hdr.ip_ttl = ipsec_xform->tunnel.ipv4.ttl; + session->ip4_hdr.ip_p = (ipsec_xform->proto == + RTE_SECURITY_IPSEC_SA_PROTO_ESP) ? IPPROTO_ESP + : IPPROTO_AH; + session->ip4_hdr.ip_sum = 0; + session->ip4_hdr.ip_src = ipsec_xform->tunnel.ipv4.src_ip; + session->ip4_hdr.ip_dst = ipsec_xform->tunnel.ipv4.dst_ip; + session->ip4_hdr.ip_sum = calc_chksum((uint16_t *) + (void *)&session->ip4_hdr, + sizeof(struct ip)); + + session->encap_pdb.options = + (IPVERSION << PDBNH_ESP_ENCAP_SHIFT) | + PDBOPTS_ESP_OIHI_PDB_INL | + PDBOPTS_ESP_IVSRC | + PDBHMO_ESP_ENCAP_DTTL; + session->encap_pdb.spi = ipsec_xform->spi; + session->encap_pdb.ip_hdr_len = sizeof(struct ip); + + session->dir = DIR_ENC; + } else if (ipsec_xform->direction == + RTE_SECURITY_IPSEC_SA_DIR_INGRESS) { + memset(&session->decap_pdb, 0, sizeof(struct ipsec_decap_pdb)); + session->decap_pdb.options = sizeof(struct ip) << 16; + session->dir = DIR_DEC; + } else + goto out; + session->ctx_pool = internals->ctx_pool; + + return 0; +out: + rte_free(session->auth_key.data); + rte_free(session->cipher_key.data); + memset(session, 0, sizeof(struct caam_jr_session)); + return -1; +} + +static int +caam_jr_security_session_create(void *dev, + struct rte_security_session_conf *conf, + struct rte_security_session *sess, + struct rte_mempool *mempool) +{ + void *sess_private_data; + struct rte_cryptodev *cdev = (struct rte_cryptodev *)dev; + int ret; + + if (rte_mempool_get(mempool, &sess_private_data)) { + CAAM_JR_ERR("Couldn't get object from session mempool"); + return -ENOMEM; + } + + switch (conf->protocol) { + case RTE_SECURITY_PROTOCOL_IPSEC: + ret = caam_jr_set_ipsec_session(cdev, conf, + sess_private_data); + break; + case RTE_SECURITY_PROTOCOL_MACSEC: + return -ENOTSUP; + default: + return -EINVAL; + } + if (ret != 0) { + CAAM_JR_ERR("failed to configure session parameters"); + /* Return session to mempool */ + rte_mempool_put(mempool, sess_private_data); + return ret; + } + + set_sec_session_private_data(sess, sess_private_data); + + return ret; +} + +/* Clear the memory of session so it doesn't leave key material behind */ +static int +caam_jr_security_session_destroy(void *dev __rte_unused, + struct rte_security_session *sess) +{ + PMD_INIT_FUNC_TRACE(); + void *sess_priv = get_sec_session_private_data(sess); + + struct caam_jr_session *s = (struct caam_jr_session *)sess_priv; + + if (sess_priv) { + struct rte_mempool *sess_mp = rte_mempool_from_obj(sess_priv); + + rte_free(s->cipher_key.data); + rte_free(s->auth_key.data); + memset(sess, 0, sizeof(struct caam_jr_session)); + set_sec_session_private_data(sess, NULL); + rte_mempool_put(sess_mp, sess_priv); + } + return 0; +} + + static int caam_jr_dev_configure(struct rte_cryptodev *dev, struct rte_cryptodev_config *config __rte_unused) @@ -1752,6 +2064,20 @@ static struct rte_cryptodev_ops caam_jr_ops = { .sym_session_clear = caam_jr_sym_session_clear }; +static const struct rte_security_capability * +caam_jr_capabilities_get(void *device __rte_unused) +{ + return caam_jr_security_cap; +} + +static struct rte_security_ops caam_jr_security_ops = { + .session_create = caam_jr_security_session_create, + .session_update = NULL, + .session_stats_get = NULL, + .session_destroy = caam_jr_security_session_destroy, + .set_pkt_metadata = NULL, + .capabilities_get = caam_jr_capabilities_get +}; /* @brief Flush job rings of any processed descs. * The processed descs are silently dropped, @@ -1970,6 +2296,7 @@ caam_jr_dev_init(const char *name, struct rte_cryptodev_pmd_init_params *init_params) { struct rte_cryptodev *dev; + struct rte_security_ctx *security_instance; struct uio_job_ring *job_ring; char str[RTE_CRYPTODEV_NAME_MAX_LEN]; @@ -2039,6 +2366,20 @@ caam_jr_dev_init(const char *name, return 0; } + /*TODO free it during teardown*/ + security_instance = rte_malloc("caam_jr", + sizeof(struct rte_security_ctx), 0); + if (security_instance == NULL) { + CAAM_JR_ERR("memory allocation failed\n"); + //todo error handling. + goto cleanup2; + } + + security_instance->device = (void *)dev; + security_instance->ops = &caam_jr_security_ops; + security_instance->sess_cnt = 0; + dev->security_ctx = security_instance; + RTE_LOG(INFO, PMD, "%s cryptodev init\n", dev->data->name); return 0; diff --git a/drivers/crypto/caam_jr/caam_jr_pvt.h b/drivers/crypto/caam_jr/caam_jr_pvt.h index cc0aa65f1..cfa2f78ae 100644 --- a/drivers/crypto/caam_jr/caam_jr_pvt.h +++ b/drivers/crypto/caam_jr/caam_jr_pvt.h @@ -110,6 +110,7 @@ struct caam_jr_session { enum rte_crypto_cipher_algorithm cipher_alg; /* Cipher Algorithm*/ enum rte_crypto_auth_algorithm auth_alg; /* Authentication Algorithm*/ enum rte_crypto_aead_algorithm aead_alg; /* AEAD Algorithm*/ + enum rte_security_session_protocol proto_alg; /* Security Algorithm*/ union { struct { uint8_t *data; /* pointer to key data */ @@ -132,7 +133,9 @@ struct caam_jr_session { } iv; /* Initialisation vector parameters */ uint16_t auth_only_len; /* Length of data for Auth only */ uint32_t digest_length; + struct ipsec_encap_pdb encap_pdb; struct ip ip4_hdr; + struct ipsec_decap_pdb decap_pdb; struct caam_jr_qp *qp; struct sec_cdb *cdb; /* cmd block associated with qp */ struct rte_mempool *ctx_pool; /* session mempool for caam_jr_op_ctx */