From patchwork Wed Jan 3 20:11:04 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Corentin Labbe X-Patchwork-Id: 123340 Delivered-To: patch@linaro.org Received: by 10.80.135.92 with SMTP id 28csp5928138edv; Wed, 3 Jan 2018 12:27:16 -0800 (PST) X-Google-Smtp-Source: ACJfBosJmWcPbRimiHUuwfCMCte/xPju+KsX0ZgOggkK+gXw4E+xRaxoLygL4tt3GbQ1Xukw1Evh X-Received: by 10.99.97.197 with SMTP id v188mr2078595pgb.291.1515011236047; Wed, 03 Jan 2018 12:27:16 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1515011236; cv=none; d=google.com; s=arc-20160816; b=Jj2xvxTFEwYs10hEUJMXp7jYPn8N+4EOoF2ohAhLbZaDv6CRz7mtrvm4NlWCfw/LYX 9j5TDkk5e2qnpIKGM8Xgyjy4CWyl8opGEODe0U331Ll2EH54myaQAxcXQZLRZS95nOrp eikXAOcqUzJ2Ts959pTF2RDyLoasC5h66XRp0Q+Q8Z8KVV3bg3NFQNszfTY2zouLTj+5 HqwP0gSLkmgyQ3M6gbBrtTtVRM3B8xK7CKCIeMCq1m0IVlmtUvnbX3VRNo2/Ibc7zehr Bs6kyWUaF662rVDzVbv3i+HfpGMD4b60i+IvN7ifjdEB3ejkHIv0Qam+1qP441ntkpzm noJg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:message-id:date :subject:cc:to:from:dkim-signature:arc-authentication-results; bh=LCg/Yvaj9+q1xWy/a3OeqgitkFC3vFLTMKm+P0lDexo=; b=zKzqmPv+IWWuRUJbhQyCHKVm2eh0lW7g/xIZy3CutBMmvzw17HJEaDiaoMaywmEC8W QvYhOVIb+9W5Jc6B9MLlAoyG8K1jCFmjvWHy2fcPST+LoH2sIXCemmyDf0DSO+Ja64Mx oYGfjPsSsi60yT5S2lOY8/BaLuUqERp0t6YjcKEnxBy4uy3sKVadXYR5xSfUz6uqbFtp pGVxeOYN6X1zsQpqnRXwwkIwoU5ZFpIUy9x/HXSK4YY82dkIPeo4L7nxLSqcIeNNKDXk tskB0keVABZyU5d6M7lRbca8xV1SAPjHBAmV5vXK8XTl1mNW9dfTaC/2gYQ5f3PPgtb6 rHmw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=l4++G9KQ; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gmail.com Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id 17si1045746pgh.538.2018.01.03.12.27.15; Wed, 03 Jan 2018 12:27:16 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=l4++G9KQ; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gmail.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752299AbeACU1M (ORCPT + 28 others); Wed, 3 Jan 2018 15:27:12 -0500 Received: from mail-wr0-f195.google.com ([209.85.128.195]:46749 "EHLO mail-wr0-f195.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752163AbeACUNW (ORCPT ); Wed, 3 Jan 2018 15:13:22 -0500 Received: by mail-wr0-f195.google.com with SMTP id g17so2832848wrd.13; Wed, 03 Jan 2018 12:13:21 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=LCg/Yvaj9+q1xWy/a3OeqgitkFC3vFLTMKm+P0lDexo=; b=l4++G9KQ+5bnsgUFy3bCes4ypUNcgyCVfYWqQWU97Rl8X+QjZT0J5IE21/JphAxXXM U2M9d9vRsv0VkH0EZe4HGGsYIA9QQB5uoDH9tD+RG3DE4IILbY2R0LCAu7j35x5DOGD/ AieIfihmGEu7ZJBMSbpJhS+Wrwk6prIVtP/725RhUfuRmcYhg40rWPlTol1hIDgaly7C jPyRCMG/pbz8rbo1bRHkm9DZFdainIb743i/NQx0I+F5Ars727kOoizQFR3wY7w9Rvj/ c9bHFKWlXssk0IAsSeoFoxpwzvC5L1mkeimb3ZkPtuW4bc4UJM+aD9yqTNtbhH9wUK00 RsqA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=LCg/Yvaj9+q1xWy/a3OeqgitkFC3vFLTMKm+P0lDexo=; b=rvEUC2LMydRUS7LB/KoLgJFncTXayf6Xp5BFE7KsWZ6/V85y1Bk28qJXTaNo9QQLXF pNZo56fUtBIoHXqjfb2m9ZaZ4ekr9cnUrxkeiRN1IKbz41+1vHIzLxK7Tc9FdYSVkP5U oYCyiLn3Vyl6IiK6bvdcDvpPoeQ8l1/em8gkE2plNxRD0I9YaTjRseaKPRgr+kiR9DeC JzY8HzjfGMb4vgdwZw5+1UNfneMT7qXmmWlZgVwShud2o7VgNnAFQ3OxuwHztgRi/ntE i59sImLh3uAShbm6X7dNQaVpl5OnoFYpFgNTuEZ48JX5cM/Yw8FInMHdcvpPnSPa+Flw xe8A== X-Gm-Message-State: AKGB3mJe47b1v/1Yi4VgE98AJLX3b9+MwZDfFOLR9WiBH5tBFTRmeEx+ TFA6LbKTV2OWvWci3ldygXXcUkX3 X-Received: by 10.223.150.178 with SMTP id u47mr2713030wrb.115.1515010400723; Wed, 03 Jan 2018 12:13:20 -0800 (PST) Received: from Red.local (LFbn-1-6953-20.w90-116.abo.wanadoo.fr. [90.116.134.20]) by smtp.googlemail.com with ESMTPSA id p90sm1800627wmf.3.2018.01.03.12.13.19 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 03 Jan 2018 12:13:20 -0800 (PST) From: Corentin Labbe To: alexandre.torgue@st.com, arei.gonglei@huawei.com, corbet@lwn.net, davem@davemloft.net, herbert@gondor.apana.org.au, jasowang@redhat.com, mcoquelin.stm32@gmail.com, mst@redhat.com Cc: linux-arm-kernel@lists.infradead.org, linux-crypto@vger.kernel.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, virtualization@lists.linux-foundation.org, fabien.dessenne@st.com, Corentin Labbe Subject: [PATCH 1/6] Documentation: crypto: document crypto engine API Date: Wed, 3 Jan 2018 21:11:04 +0100 Message-Id: <20180103201109.16077-2-clabbe.montjoie@gmail.com> X-Mailer: git-send-email 2.13.6 In-Reply-To: <20180103201109.16077-1-clabbe.montjoie@gmail.com> References: <20180103201109.16077-1-clabbe.montjoie@gmail.com> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Signed-off-by: Corentin Labbe --- Documentation/crypto/crypto_engine.rst | 46 ++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 Documentation/crypto/crypto_engine.rst -- 2.13.6 diff --git a/Documentation/crypto/crypto_engine.rst b/Documentation/crypto/crypto_engine.rst new file mode 100644 index 000000000000..b0ed37f9fb0c --- /dev/null +++ b/Documentation/crypto/crypto_engine.rst @@ -0,0 +1,46 @@ +============= +CRYPTO ENGINE +============= + +Overview +-------- +The crypto engine API (CE), is a crypto queue manager. + +Requirement +----------- +You have to put at start of your tfm_ctx the struct crypto_engine_reqctx +struct your_tfm_ctx { + struct crypto_engine_reqctx enginectx; + ... +}; +Why: Since CE manage only crypto_async_request, it cannot know the underlying +request_type and so have access only on the TFM. +So using container_of for accessing __ctx is impossible. +Furthermore, the crypto engine cannot know the "struct your_tfm_ctx", +so it must assume that crypto_engine_reqctx is at start of it. + +Order of operations +------------------- +You have to obtain a struct crypto_engine via crypto_engine_alloc_init(). +And start it via crypto_engine_start(). + +Before transferring any request, you have to fill the enginectx. +- prepare_request: (taking a function pointer) If you need to do some processing before doing the request +- unprepare_request: (taking a function pointer) Undoing what's done in prepare_request +- do_one_request: (taking a function pointer) Do encryption for current request + +Note: that those three functions get the crypto_async_request associated with the received request. +So your need to get the original request via container_of(areq, struct yourrequesttype_request, base); + +When your driver receive a crypto_request, you have to transfer it to +the cryptoengine via one of: +- crypto_transfer_cipher_request_to_engine() +- crypto_transfer_skcipher_request_to_engine() +- crypto_transfer_akcipher_request_to_engine() +- crypto_transfer_hash_request_to_engine() + +At the end of the request process, a call to one of the following function is needed: +- crypto_finalize_cipher_request +- crypto_finalize_skcipher_request +- crypto_finalize_akcipher_request +- crypto_finalize_hash_request From patchwork Wed Jan 3 20:11:05 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Corentin Labbe X-Patchwork-Id: 123339 Delivered-To: patch@linaro.org Received: by 10.80.135.92 with SMTP id 28csp5927588edv; Wed, 3 Jan 2018 12:26:36 -0800 (PST) X-Google-Smtp-Source: ACJfBouhqzGQ5Jvff1nNCFB4IRhskp0EGCRwbxuf0njUpoKgflKYN7YyvA9O+KjUH7usO7QZjhgn X-Received: by 10.98.189.17 with SMTP id a17mr2449873pff.97.1515011196348; Wed, 03 Jan 2018 12:26:36 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1515011196; cv=none; d=google.com; s=arc-20160816; b=gOaTznj7CAmwdRE6P8JYVhHkMA73l4w8r3RjxqknZ4TN95MLeTU4M35ZOtbItARpYO je9fRMQEJf4Pl74x26+UvPqgyGxosg4goG3j3heNxjgvy5wL3c2IwNWhUlN/+rOzjgs6 RckrzBqDCvXAdcdHECwAZ9Shqlpmvqx2Y3qOVxCyB2EYVF5lMLBlRnKfgiUa4wAw4ekb OKxRdG51HyQVBEVoxln356Tclw8uenKkd1un9ABoMf+Elg9MtdmwAgf9pHtHLjCr94Lc WF1xeRCLQXbR8BZESp64BpT00p/Af3lfLoxlM+arZy2oZNrp5wmXijg0xXbe+LNsWzTk OEnA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:message-id:date :subject:cc:to:from:dkim-signature:arc-authentication-results; bh=zunPPG2BwHmcsRUwRdvXiJcoUHQmQSE1n2d3Tf9FqSQ=; b=0d2OvzIDNi3cAcTO8sMCoxwPezfODF3ZUy2bBknBeFzkbuzDLomjfZ0FLrcJNXtskf h4AExcxphYSwattsrZKOx4+Sv2CFZX3exZfOMjZ4otNFBy2Te7jrdZu3E6WASWYoWDgu JsOwnrcw492DoFIMUu5QfCDxw3vIO/WznFmPB6+hecw6cJWWfZotaDHHIcrtREwAEWQj xgmfqO4BEV9GUw9UgvNSizwNtsKWHK5WyBFPEEH69Oe8jF2BmIKr1DiX3Z5ePzGzUd9U 4ueOflZ7t9ykTjheG2Dr3TSpuabjdjiysyzozAhj/uXYNO/tuLfpZvbotPdcglSk29Lu oxSA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=Y9SWnsp0; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gmail.com Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id z3si1156565pfh.370.2018.01.03.12.26.36; Wed, 03 Jan 2018 12:26:36 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=Y9SWnsp0; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gmail.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752453AbeACU0d (ORCPT + 28 others); Wed, 3 Jan 2018 15:26:33 -0500 Received: from mail-wr0-f196.google.com ([209.85.128.196]:39037 "EHLO mail-wr0-f196.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751361AbeACUNY (ORCPT ); Wed, 3 Jan 2018 15:13:24 -0500 Received: by mail-wr0-f196.google.com with SMTP id o101so2843940wrb.6; Wed, 03 Jan 2018 12:13:23 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=zunPPG2BwHmcsRUwRdvXiJcoUHQmQSE1n2d3Tf9FqSQ=; b=Y9SWnsp0Skjnd0rLYMPDnBRpIoo9F6TmPnjEls0bXglF4uFOmlocwkD2xjfLBb56vP aQe9M76+9i8qOZF7q3+infO/CyDB1HWVaPZTKeD8MVZPmIIfKoE5DscvLxEFCNbc98Fj dyH38gTtB5UTL7EJ8SaFkgXLAP6o03IN2cI47bjX+BQnrzcCeb+lGYNycaX3H8Gz+MZr IVZSN9JMrqMuc/GxCOPggPh6JSrAn8O6OJDCt8NL7OZ91RY/CC8cVPryMVaoheAn2Oto VGHQfMfJFdc/QxlZluaz00ptk+3j58DXJmQTh5+2k5RzEVM+0G1eLTt6+5/KKOmeJbzQ dEsg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=zunPPG2BwHmcsRUwRdvXiJcoUHQmQSE1n2d3Tf9FqSQ=; b=dXY+/IXUTAo915aBRt0s+vk/6DGp1xq0wIT6ofdinqgnwrs4fjmAHZsWYHhwz3I6jD nCiHuj2rxsqOoR4ltz4FyAGcPHfF6gGUYMQPHCv0IcSuJ9ACXiRQhfEVwH815n29bvQZ cpLz1Qy486bAz32xYkKOA+ye31i3fu+w9Gl0qfD6zkLwqT0mGfx3wWWzjffR+MyVYFvq 4vfMoPYtieW7hXAXsus9fy6+GnwV3R3Ly+K2mGpxbUQ1Q2cX8QYc2/aCIgc4O1GCIXw7 DEdW9OWo7E1klDJ0DCKF0uRiVVHo18+QZseRpGwuy2x2IgLLzwgHmIg5DgQuQOHIxTQf IzMg== X-Gm-Message-State: AKGB3mJ0Iv/QQvF2qNkErCuaDb3tXCWBdEQ6vNWx3oGmpMOT6IzNrv2P ClKj37rqtF1QxNW42gNnQtY= X-Received: by 10.223.172.120 with SMTP id v111mr2643333wrc.195.1515010402297; Wed, 03 Jan 2018 12:13:22 -0800 (PST) Received: from Red.local (LFbn-1-6953-20.w90-116.abo.wanadoo.fr. [90.116.134.20]) by smtp.googlemail.com with ESMTPSA id p90sm1800627wmf.3.2018.01.03.12.13.20 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 03 Jan 2018 12:13:21 -0800 (PST) From: Corentin Labbe To: alexandre.torgue@st.com, arei.gonglei@huawei.com, corbet@lwn.net, davem@davemloft.net, herbert@gondor.apana.org.au, jasowang@redhat.com, mcoquelin.stm32@gmail.com, mst@redhat.com Cc: linux-arm-kernel@lists.infradead.org, linux-crypto@vger.kernel.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, virtualization@lists.linux-foundation.org, fabien.dessenne@st.com, Corentin Labbe Subject: [PATCH 2/6] crypto: engine - Permit to enqueue all async requests Date: Wed, 3 Jan 2018 21:11:05 +0100 Message-Id: <20180103201109.16077-3-clabbe.montjoie@gmail.com> X-Mailer: git-send-email 2.13.6 In-Reply-To: <20180103201109.16077-1-clabbe.montjoie@gmail.com> References: <20180103201109.16077-1-clabbe.montjoie@gmail.com> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The crypto engine could actually only enqueue hash and ablkcipher request. This patch permit it to enqueue any type of crypto_async_request. Signed-off-by: Corentin Labbe --- crypto/crypto_engine.c | 230 ++++++++++++++++++++++++------------------------ include/crypto/engine.h | 59 +++++++------ 2 files changed, 148 insertions(+), 141 deletions(-) -- 2.13.6 diff --git a/crypto/crypto_engine.c b/crypto/crypto_engine.c index 61e7c4e02fd2..036270b61648 100644 --- a/crypto/crypto_engine.c +++ b/crypto/crypto_engine.c @@ -15,7 +15,6 @@ #include #include #include -#include #include #include "internal.h" @@ -34,11 +33,10 @@ static void crypto_pump_requests(struct crypto_engine *engine, bool in_kthread) { struct crypto_async_request *async_req, *backlog; - struct ahash_request *hreq; - struct ablkcipher_request *breq; unsigned long flags; bool was_busy = false; - int ret, rtype; + int ret; + struct crypto_engine_reqctx *enginectx; spin_lock_irqsave(&engine->queue_lock, flags); @@ -94,7 +92,6 @@ static void crypto_pump_requests(struct crypto_engine *engine, spin_unlock_irqrestore(&engine->queue_lock, flags); - rtype = crypto_tfm_alg_type(engine->cur_req->tfm); /* Until here we get the request need to be encrypted successfully */ if (!was_busy && engine->prepare_crypt_hardware) { ret = engine->prepare_crypt_hardware(engine); @@ -104,57 +101,31 @@ static void crypto_pump_requests(struct crypto_engine *engine, } } - switch (rtype) { - case CRYPTO_ALG_TYPE_AHASH: - hreq = ahash_request_cast(engine->cur_req); - if (engine->prepare_hash_request) { - ret = engine->prepare_hash_request(engine, hreq); - if (ret) { - dev_err(engine->dev, "failed to prepare request: %d\n", - ret); - goto req_err; - } - engine->cur_req_prepared = true; - } - ret = engine->hash_one_request(engine, hreq); - if (ret) { - dev_err(engine->dev, "failed to hash one request from queue\n"); - goto req_err; - } - return; - case CRYPTO_ALG_TYPE_ABLKCIPHER: - breq = ablkcipher_request_cast(engine->cur_req); - if (engine->prepare_cipher_request) { - ret = engine->prepare_cipher_request(engine, breq); - if (ret) { - dev_err(engine->dev, "failed to prepare request: %d\n", - ret); - goto req_err; - } - engine->cur_req_prepared = true; - } - ret = engine->cipher_one_request(engine, breq); + enginectx = crypto_tfm_ctx(async_req->tfm); + + if (enginectx->op.prepare_request) { + ret = enginectx->op.prepare_request(engine, async_req); if (ret) { - dev_err(engine->dev, "failed to cipher one request from queue\n"); + dev_err(engine->dev, "failed to prepare request: %d\n", + ret); goto req_err; } - return; - default: - dev_err(engine->dev, "failed to prepare request of unknown type\n"); - return; + engine->cur_req_prepared = true; + } + if (!enginectx->op.do_one_request) { + dev_err(engine->dev, "failed to do request\n"); + ret = -EINVAL; + goto req_err; + } + ret = enginectx->op.do_one_request(engine, async_req); + if (ret) { + dev_err(engine->dev, "Failed to do one request from queue: %d\n", ret); + goto req_err; } + return; req_err: - switch (rtype) { - case CRYPTO_ALG_TYPE_AHASH: - hreq = ahash_request_cast(engine->cur_req); - crypto_finalize_hash_request(engine, hreq, ret); - break; - case CRYPTO_ALG_TYPE_ABLKCIPHER: - breq = ablkcipher_request_cast(engine->cur_req); - crypto_finalize_cipher_request(engine, breq, ret); - break; - } + crypto_finalize_request(engine, async_req, ret); return; out: @@ -170,13 +141,12 @@ static void crypto_pump_work(struct kthread_work *work) } /** - * crypto_transfer_cipher_request - transfer the new request into the - * enginequeue + * crypto_transfer_request - transfer the new request into the engine queue * @engine: the hardware engine * @req: the request need to be listed into the engine queue */ -int crypto_transfer_cipher_request(struct crypto_engine *engine, - struct ablkcipher_request *req, +static int crypto_transfer_request(struct crypto_engine *engine, + struct crypto_async_request *req, bool need_pump) { unsigned long flags; @@ -189,7 +159,7 @@ int crypto_transfer_cipher_request(struct crypto_engine *engine, return -ESHUTDOWN; } - ret = ablkcipher_enqueue_request(&engine->queue, req); + ret = crypto_enqueue_request(&engine->queue, req); if (!engine->busy && need_pump) kthread_queue_work(engine->kworker, &engine->pump_requests); @@ -197,85 +167,97 @@ int crypto_transfer_cipher_request(struct crypto_engine *engine, spin_unlock_irqrestore(&engine->queue_lock, flags); return ret; } -EXPORT_SYMBOL_GPL(crypto_transfer_cipher_request); +EXPORT_SYMBOL_GPL(crypto_transfer_request); /** - * crypto_transfer_cipher_request_to_engine - transfer one request to list + * crypto_transfer_request_to_engine - transfer one request to list * into the engine queue * @engine: the hardware engine * @req: the request need to be listed into the engine queue */ +static int crypto_transfer_request_to_engine(struct crypto_engine *engine, + struct crypto_async_request *req) +{ + return crypto_transfer_request(engine, req, true); +} + +/** + * crypto_transfer_cipher_request_to_engine - transfer one ablkcipher_request + * to list into the engine queue + * @engine: the hardware engine + * @req: the request need to be listed into the engine queue + * TODO: Remove this function when skcipher conversion is finished + */ int crypto_transfer_cipher_request_to_engine(struct crypto_engine *engine, struct ablkcipher_request *req) { - return crypto_transfer_cipher_request(engine, req, true); + return crypto_transfer_request_to_engine(engine, &req->base); } EXPORT_SYMBOL_GPL(crypto_transfer_cipher_request_to_engine); /** - * crypto_transfer_hash_request - transfer the new request into the - * enginequeue + * crypto_transfer_skcipher_request_to_engine - transfer one skcipher_request + * to list into the engine queue * @engine: the hardware engine * @req: the request need to be listed into the engine queue */ -int crypto_transfer_hash_request(struct crypto_engine *engine, - struct ahash_request *req, bool need_pump) +int crypto_transfer_skcipher_request_to_engine(struct crypto_engine *engine, + struct skcipher_request *req) { - unsigned long flags; - int ret; - - spin_lock_irqsave(&engine->queue_lock, flags); - - if (!engine->running) { - spin_unlock_irqrestore(&engine->queue_lock, flags); - return -ESHUTDOWN; - } - - ret = ahash_enqueue_request(&engine->queue, req); - - if (!engine->busy && need_pump) - kthread_queue_work(engine->kworker, &engine->pump_requests); + return crypto_transfer_request_to_engine(engine, &req->base); +} +EXPORT_SYMBOL_GPL(crypto_transfer_skcipher_request_to_engine); - spin_unlock_irqrestore(&engine->queue_lock, flags); - return ret; +/** + * crypto_transfer_akcipher_request_to_engine - transfer one akcipher_request + * to list into the engine queue + * @engine: the hardware engine + * @req: the request need to be listed into the engine queue + */ +int crypto_transfer_akcipher_request_to_engine(struct crypto_engine *engine, + struct akcipher_request *req) +{ + return crypto_transfer_request_to_engine(engine, &req->base); } -EXPORT_SYMBOL_GPL(crypto_transfer_hash_request); +EXPORT_SYMBOL_GPL(crypto_transfer_akcipher_request_to_engine); /** - * crypto_transfer_hash_request_to_engine - transfer one request to list - * into the engine queue + * crypto_transfer_hash_request_to_engine - transfer one ahash_request + * to list into the engine queue * @engine: the hardware engine * @req: the request need to be listed into the engine queue */ int crypto_transfer_hash_request_to_engine(struct crypto_engine *engine, struct ahash_request *req) { - return crypto_transfer_hash_request(engine, req, true); + return crypto_transfer_request_to_engine(engine, &req->base); } EXPORT_SYMBOL_GPL(crypto_transfer_hash_request_to_engine); /** - * crypto_finalize_cipher_request - finalize one request if the request is done + * crypto_finalize_request - finalize one request if the request is done * @engine: the hardware engine * @req: the request need to be finalized * @err: error number */ -void crypto_finalize_cipher_request(struct crypto_engine *engine, - struct ablkcipher_request *req, int err) +void crypto_finalize_request(struct crypto_engine *engine, + struct crypto_async_request *req, int err) { unsigned long flags; bool finalize_cur_req = false; int ret; + struct crypto_engine_reqctx *enginectx; spin_lock_irqsave(&engine->queue_lock, flags); - if (engine->cur_req == &req->base) + if (engine->cur_req == req) finalize_cur_req = true; spin_unlock_irqrestore(&engine->queue_lock, flags); if (finalize_cur_req) { + enginectx = crypto_tfm_ctx(req->tfm); if (engine->cur_req_prepared && - engine->unprepare_cipher_request) { - ret = engine->unprepare_cipher_request(engine, req); + enginectx->op.unprepare_request) { + ret = enginectx->op.unprepare_request(engine, req); if (ret) dev_err(engine->dev, "failed to unprepare request\n"); } @@ -285,46 +267,64 @@ void crypto_finalize_cipher_request(struct crypto_engine *engine, spin_unlock_irqrestore(&engine->queue_lock, flags); } - req->base.complete(&req->base, err); + req->complete(req, err); kthread_queue_work(engine->kworker, &engine->pump_requests); } -EXPORT_SYMBOL_GPL(crypto_finalize_cipher_request); /** - * crypto_finalize_hash_request - finalize one request if the request is done + * crypto_finalize_cipher_request - finalize one ablkcipher_request if + * the request is done * @engine: the hardware engine * @req: the request need to be finalized * @err: error number */ -void crypto_finalize_hash_request(struct crypto_engine *engine, - struct ahash_request *req, int err) +void crypto_finalize_cipher_request(struct crypto_engine *engine, + struct ablkcipher_request *req, int err) { - unsigned long flags; - bool finalize_cur_req = false; - int ret; - - spin_lock_irqsave(&engine->queue_lock, flags); - if (engine->cur_req == &req->base) - finalize_cur_req = true; - spin_unlock_irqrestore(&engine->queue_lock, flags); + return crypto_finalize_request(engine, &req->base, err); +} +EXPORT_SYMBOL_GPL(crypto_finalize_cipher_request); - if (finalize_cur_req) { - if (engine->cur_req_prepared && - engine->unprepare_hash_request) { - ret = engine->unprepare_hash_request(engine, req); - if (ret) - dev_err(engine->dev, "failed to unprepare request\n"); - } - spin_lock_irqsave(&engine->queue_lock, flags); - engine->cur_req = NULL; - engine->cur_req_prepared = false; - spin_unlock_irqrestore(&engine->queue_lock, flags); - } +/** + * crypto_finalize_skcipher_request - finalize one skcipher_request if + * the request is done + * @engine: the hardware engine + * @req: the request need to be finalized + * @err: error number + */ +void crypto_finalize_skcipher_request(struct crypto_engine *engine, + struct skcipher_request *req, int err) +{ + return crypto_finalize_request(engine, &req->base, err); +} +EXPORT_SYMBOL_GPL(crypto_finalize_skcipher_request); - req->base.complete(&req->base, err); +/** + * crypto_finalize_akcipher_request - finalize one akcipher_request if + * the request is done + * @engine: the hardware engine + * @req: the request need to be finalized + * @err: error number + */ +void crypto_finalize_akcipher_request(struct crypto_engine *engine, + struct akcipher_request *req, int err) +{ + return crypto_finalize_request(engine, &req->base, err); +} +EXPORT_SYMBOL_GPL(crypto_finalize_akcipher_request); - kthread_queue_work(engine->kworker, &engine->pump_requests); +/** + * crypto_finalize_hash_request - finalize one ahash_request if + * the request is done + * @engine: the hardware engine + * @req: the request need to be finalized + * @err: error number + */ +void crypto_finalize_hash_request(struct crypto_engine *engine, + struct ahash_request *req, int err) +{ + return crypto_finalize_request(engine, &req->base, err); } EXPORT_SYMBOL_GPL(crypto_finalize_hash_request); diff --git a/include/crypto/engine.h b/include/crypto/engine.h index dd04c1699b51..1ea7cbe92eaf 100644 --- a/include/crypto/engine.h +++ b/include/crypto/engine.h @@ -17,7 +17,9 @@ #include #include #include +#include #include +#include #define ENGINE_NAME_LEN 30 /* @@ -37,12 +39,6 @@ * @unprepare_crypt_hardware: there are currently no more requests on the * queue so the subsystem notifies the driver that it may relax the * hardware by issuing this call - * @prepare_cipher_request: do some prepare if need before handle the current request - * @unprepare_cipher_request: undo any work done by prepare_cipher_request() - * @cipher_one_request: do encryption for current request - * @prepare_hash_request: do some prepare if need before handle the current request - * @unprepare_hash_request: undo any work done by prepare_hash_request() - * @hash_one_request: do hash for current request * @kworker: kthread worker struct for request pump * @pump_requests: work struct for scheduling work to the request pump * @priv_data: the engine private data @@ -65,19 +61,6 @@ struct crypto_engine { int (*prepare_crypt_hardware)(struct crypto_engine *engine); int (*unprepare_crypt_hardware)(struct crypto_engine *engine); - int (*prepare_cipher_request)(struct crypto_engine *engine, - struct ablkcipher_request *req); - int (*unprepare_cipher_request)(struct crypto_engine *engine, - struct ablkcipher_request *req); - int (*prepare_hash_request)(struct crypto_engine *engine, - struct ahash_request *req); - int (*unprepare_hash_request)(struct crypto_engine *engine, - struct ahash_request *req); - int (*cipher_one_request)(struct crypto_engine *engine, - struct ablkcipher_request *req); - int (*hash_one_request)(struct crypto_engine *engine, - struct ahash_request *req); - struct kthread_worker *kworker; struct kthread_work pump_requests; @@ -85,19 +68,43 @@ struct crypto_engine { struct crypto_async_request *cur_req; }; -int crypto_transfer_cipher_request(struct crypto_engine *engine, - struct ablkcipher_request *req, - bool need_pump); +/* + * struct crypto_engine_op - crypto hardware engine operations + * @prepare__request: do some prepare if need before handle the current request + * @unprepare_request: undo any work done by prepare_request() + * @do_one_request: do encryption for current request + */ +struct crypto_engine_op { + int (*prepare_request)(struct crypto_engine *engine, + void *areq); + int (*unprepare_request)(struct crypto_engine *engine, + void *areq); + int (*do_one_request)(struct crypto_engine *engine, + void *areq); +}; + +struct crypto_engine_reqctx { + struct crypto_engine_op op; +}; + +int crypto_transfer_akcipher_request_to_engine(struct crypto_engine *engine, + struct akcipher_request *req); int crypto_transfer_cipher_request_to_engine(struct crypto_engine *engine, - struct ablkcipher_request *req); -int crypto_transfer_hash_request(struct crypto_engine *engine, - struct ahash_request *req, bool need_pump); + struct ablkcipher_request *req); int crypto_transfer_hash_request_to_engine(struct crypto_engine *engine, - struct ahash_request *req); + struct ahash_request *req); +int crypto_transfer_skcipher_request_to_engine(struct crypto_engine *engine, + struct skcipher_request *req); +void crypto_finalize_request(struct crypto_engine *engine, + struct crypto_async_request *req, int err); +void crypto_finalize_akcipher_request(struct crypto_engine *engine, + struct akcipher_request *req, int err); void crypto_finalize_cipher_request(struct crypto_engine *engine, struct ablkcipher_request *req, int err); void crypto_finalize_hash_request(struct crypto_engine *engine, struct ahash_request *req, int err); +void crypto_finalize_skcipher_request(struct crypto_engine *engine, + struct skcipher_request *req, int err); int crypto_engine_start(struct crypto_engine *engine); int crypto_engine_stop(struct crypto_engine *engine); struct crypto_engine *crypto_engine_alloc_init(struct device *dev, bool rt); From patchwork Wed Jan 3 20:11:06 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Corentin Labbe X-Patchwork-Id: 123335 Delivered-To: patch@linaro.org Received: by 10.80.135.92 with SMTP id 28csp5916154edv; Wed, 3 Jan 2018 12:13:34 -0800 (PST) X-Google-Smtp-Source: ACJfBotPVhiRsRGqyOLkzFE9AWeIHPvixu6ajRTG+zynpq5J8DMLhXgkFc5D+ZxYp3XkmkGG57br X-Received: by 10.98.149.72 with SMTP id p69mr2511143pfd.76.1515010414064; Wed, 03 Jan 2018 12:13:34 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1515010414; cv=none; d=google.com; s=arc-20160816; b=KcUmphbB9g/v5FLwFaEuRe2hA7Rrbf1v7boUAIYcfhXS3rWbsivj9I+bB9BDkxPfa8 f8KOH5TXc0Op9qSVl13Xo2Wk6uVoN5MpkwKouEZ1IIsUoB6PKP19us//ZpES82wiz/ue KYj5GQ75Zc25ZbjEVz7jmJv5mCsPtNRRQa+QK5MkkM1qWcMZLFIfxhKCUV66cuYDpDQa a0MmcJteNopS1d3FUSqui4TWi+eiUafrlXnhEUj1YSIb8+lenqKjzV1ooyWkqgEGvCV3 EPVS3cpGPHkXaZgPW9C2aFDwFG7//WnUj3O2DylyJMO4YZt9Tm+V11HxRKf0ILcJxN3C waBQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:message-id:date :subject:cc:to:from:dkim-signature:arc-authentication-results; bh=jshDj9h+QKs88X5CaYnVSG6+6y6vGaTUjoZiRW7EPS4=; b=tQKMub4xF18IWh3Ey1mwCc8UJ7Tr9KuXjXaybhoY0ujA9OK6PhwjAhSYiidN5GBsDW 4Eiqd7Tl76kTGjRjrR4MQtHf+yqvyYgWY1asmG8O1dZGXs/Yw8+XfK9fRe0VZvnxQyk+ eW0yFGgv/Z2TeOMeNL4Q096jxNCv8bnEzG+7gXJQ2aF7eReN3g9ftiOW8FBwYqd6RgWi 2l50EJ2Iy0wsffql2E4uUNFbaEzfLAvEM7sYWczW7eBmHUuvNasrCcHESRBQRbkgzo3A KlnYC5Zb47MrOfjPWs53OkBXKXmoPDH2Ayr/0G8YdKyEQKLH8sEuCzrOujSLbkeYOzH3 xpHA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=L2Jz0Cab; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gmail.com Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id f81si1143972pfh.346.2018.01.03.12.13.33; Wed, 03 Jan 2018 12:13:34 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=L2Jz0Cab; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gmail.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752239AbeACUNa (ORCPT + 28 others); Wed, 3 Jan 2018 15:13:30 -0500 Received: from mail-wr0-f193.google.com ([209.85.128.193]:46756 "EHLO mail-wr0-f193.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752177AbeACUNZ (ORCPT ); Wed, 3 Jan 2018 15:13:25 -0500 Received: by mail-wr0-f193.google.com with SMTP id g17so2833103wrd.13; Wed, 03 Jan 2018 12:13:24 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=jshDj9h+QKs88X5CaYnVSG6+6y6vGaTUjoZiRW7EPS4=; b=L2Jz0CabB/kZkazZAVZ3DKN/rt9WLneRWnwyxgnpmcsTp/PVkjfeUjxWdQRFAu4Wd+ rpVVAI3PXL3VynwNhtxikZwE7yEKCDd+BAgotOljAxxRe9JrcIS78C1s0/27I7xL1UoW RK+fwkp0pfhEXhfpdzvVamzCpWVgDxsbK4xOvGq9ZDZbsR0URlinbFAhCZa27z/W8kE/ ZvQPLVRdtJaLyvI4V+akBQMUyMr26HFRTJOrvzc2/QNkCxjXckgt45vfjkl7B0waseer JxwR5FHx1YnikOUIWTyUgLwlmJnRd+acDwoHb+ToZSGLaSdyARMau/Bf55cPaP4iGIfE 2G4Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=jshDj9h+QKs88X5CaYnVSG6+6y6vGaTUjoZiRW7EPS4=; b=BZB0qdcPOeyGb4jkyPO2XUMim/9mtvGh9xxgzlB1leZMRobdjPUoSIry9sdbuaR2dJ gAWx6bK4qvOIwKGhEhi6fWYyIPgit9pvD1FmvwaJRpJ9O01dIWeMRboP8S1nHpryvuPO rdR78RV5F9AtNISLrTOmoQ9ZtcOIkQzDVRjV8p4giNHUeJs5UNLt5PeFw3ihwnjtR01k dLfKg42/TE80OegNU0gRrvQfg2WYSmVGYXNLRNyFWwsVUeg7VqhysQDTjxbwP86f7+GH /5gPApZkFkdsaQWm+9Wtb/zall9oxzO7+noxowYG/UBCVwpL6DEAWLzcB83EftsRacPU zHiQ== X-Gm-Message-State: AKGB3mIJEUdAUoGVY8fGlPVAWaOdwhCYBs703tyQxdeehOn2Bd1ueryZ GfedUzWuKL9KVPSSps0jhtw= X-Received: by 10.223.157.135 with SMTP id p7mr2735228wre.204.1515010403796; Wed, 03 Jan 2018 12:13:23 -0800 (PST) Received: from Red.local (LFbn-1-6953-20.w90-116.abo.wanadoo.fr. [90.116.134.20]) by smtp.googlemail.com with ESMTPSA id p90sm1800627wmf.3.2018.01.03.12.13.22 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 03 Jan 2018 12:13:23 -0800 (PST) From: Corentin Labbe To: alexandre.torgue@st.com, arei.gonglei@huawei.com, corbet@lwn.net, davem@davemloft.net, herbert@gondor.apana.org.au, jasowang@redhat.com, mcoquelin.stm32@gmail.com, mst@redhat.com Cc: linux-arm-kernel@lists.infradead.org, linux-crypto@vger.kernel.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, virtualization@lists.linux-foundation.org, fabien.dessenne@st.com, Corentin Labbe Subject: [PATCH 3/6] crypto: omap: convert to new crypto engine API Date: Wed, 3 Jan 2018 21:11:06 +0100 Message-Id: <20180103201109.16077-4-clabbe.montjoie@gmail.com> X-Mailer: git-send-email 2.13.6 In-Reply-To: <20180103201109.16077-1-clabbe.montjoie@gmail.com> References: <20180103201109.16077-1-clabbe.montjoie@gmail.com> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This patch convert the driver to the new crypto engine API. Signed-off-by: Corentin Labbe --- drivers/crypto/omap-aes.c | 17 +++++++++++++---- drivers/crypto/omap-aes.h | 3 +++ drivers/crypto/omap-des.c | 20 ++++++++++++++++---- 3 files changed, 32 insertions(+), 8 deletions(-) -- 2.13.6 diff --git a/drivers/crypto/omap-aes.c b/drivers/crypto/omap-aes.c index fbec0a2e76dd..518b94628166 100644 --- a/drivers/crypto/omap-aes.c +++ b/drivers/crypto/omap-aes.c @@ -414,8 +414,9 @@ static int omap_aes_handle_queue(struct omap_aes_dev *dd, } static int omap_aes_prepare_req(struct crypto_engine *engine, - struct ablkcipher_request *req) + void *areq) { + struct ablkcipher_request *req = container_of(areq, struct ablkcipher_request, base); struct omap_aes_ctx *ctx = crypto_ablkcipher_ctx( crypto_ablkcipher_reqtfm(req)); struct omap_aes_reqctx *rctx = ablkcipher_request_ctx(req); @@ -468,8 +469,9 @@ static int omap_aes_prepare_req(struct crypto_engine *engine, } static int omap_aes_crypt_req(struct crypto_engine *engine, - struct ablkcipher_request *req) + void *areq) { + struct ablkcipher_request *req = container_of(areq, struct ablkcipher_request, base); struct omap_aes_reqctx *rctx = ablkcipher_request_ctx(req); struct omap_aes_dev *dd = rctx->dd; @@ -601,6 +603,11 @@ static int omap_aes_ctr_decrypt(struct ablkcipher_request *req) return omap_aes_crypt(req, FLAGS_CTR); } +static int omap_aes_prepare_req(struct crypto_engine *engine, + void *req); +static int omap_aes_crypt_req(struct crypto_engine *engine, + void *req); + static int omap_aes_cra_init(struct crypto_tfm *tfm) { const char *name = crypto_tfm_alg_name(tfm); @@ -616,6 +623,10 @@ static int omap_aes_cra_init(struct crypto_tfm *tfm) tfm->crt_ablkcipher.reqsize = sizeof(struct omap_aes_reqctx); + ctx->enginectx.op.prepare_request = omap_aes_prepare_req; + ctx->enginectx.op.unprepare_request = NULL; + ctx->enginectx.op.do_one_request = omap_aes_crypt_req; + return 0; } @@ -1119,8 +1130,6 @@ static int omap_aes_probe(struct platform_device *pdev) goto err_engine; } - dd->engine->prepare_cipher_request = omap_aes_prepare_req; - dd->engine->cipher_one_request = omap_aes_crypt_req; err = crypto_engine_start(dd->engine); if (err) goto err_engine; diff --git a/drivers/crypto/omap-aes.h b/drivers/crypto/omap-aes.h index 8906342e2b9a..f6ce94907ade 100644 --- a/drivers/crypto/omap-aes.h +++ b/drivers/crypto/omap-aes.h @@ -13,6 +13,8 @@ #ifndef __OMAP_AES_H__ #define __OMAP_AES_H__ +#include + #define DST_MAXBURST 4 #define DMA_MIN (DST_MAXBURST * sizeof(u32)) @@ -95,6 +97,7 @@ struct omap_aes_gcm_result { }; struct omap_aes_ctx { + struct crypto_engine_reqctx enginectx; int keylen; u32 key[AES_KEYSIZE_256 / sizeof(u32)]; u8 nonce[4]; diff --git a/drivers/crypto/omap-des.c b/drivers/crypto/omap-des.c index ebc5c0f11f03..c6a3b0490616 100644 --- a/drivers/crypto/omap-des.c +++ b/drivers/crypto/omap-des.c @@ -86,6 +86,7 @@ #define FLAGS_OUT_DATA_ST_SHIFT 10 struct omap_des_ctx { + struct crypto_engine_reqctx enginectx; struct omap_des_dev *dd; int keylen; @@ -526,8 +527,9 @@ static int omap_des_handle_queue(struct omap_des_dev *dd, } static int omap_des_prepare_req(struct crypto_engine *engine, - struct ablkcipher_request *req) + void *areq) { + struct ablkcipher_request *req = container_of(areq, struct ablkcipher_request, base); struct omap_des_ctx *ctx = crypto_ablkcipher_ctx( crypto_ablkcipher_reqtfm(req)); struct omap_des_dev *dd = omap_des_find_dev(ctx); @@ -582,8 +584,9 @@ static int omap_des_prepare_req(struct crypto_engine *engine, } static int omap_des_crypt_req(struct crypto_engine *engine, - struct ablkcipher_request *req) + void *areq) { + struct ablkcipher_request *req = container_of(areq, struct ablkcipher_request, base); struct omap_des_ctx *ctx = crypto_ablkcipher_ctx( crypto_ablkcipher_reqtfm(req)); struct omap_des_dev *dd = omap_des_find_dev(ctx); @@ -695,12 +698,23 @@ static int omap_des_cbc_decrypt(struct ablkcipher_request *req) return omap_des_crypt(req, FLAGS_CBC); } +static int omap_des_prepare_req(struct crypto_engine *engine, + void *areq); +static int omap_des_crypt_req(struct crypto_engine *engine, + void *areq); + static int omap_des_cra_init(struct crypto_tfm *tfm) { + struct omap_des_ctx *ctx = crypto_tfm_ctx(tfm); + pr_debug("enter\n"); tfm->crt_ablkcipher.reqsize = sizeof(struct omap_des_reqctx); + ctx->enginectx.op.prepare_request = omap_des_prepare_req; + ctx->enginectx.op.unprepare_request = NULL; + ctx->enginectx.op.do_one_request = omap_des_crypt_req; + return 0; } @@ -1046,8 +1060,6 @@ static int omap_des_probe(struct platform_device *pdev) goto err_engine; } - dd->engine->prepare_cipher_request = omap_des_prepare_req; - dd->engine->cipher_one_request = omap_des_crypt_req; err = crypto_engine_start(dd->engine); if (err) goto err_engine; From patchwork Wed Jan 3 20:11:07 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Corentin Labbe X-Patchwork-Id: 123338 Delivered-To: patch@linaro.org Received: by 10.80.135.92 with SMTP id 28csp5927025edv; Wed, 3 Jan 2018 12:25:49 -0800 (PST) X-Google-Smtp-Source: ACJfBou8hnMmaA0ljScCFNdg3LEiYhy7Ax6rexaHQOP+w+D+nB8YhieDWSiAaygmlPJcvUh/nkK4 X-Received: by 10.84.168.3 with SMTP id e3mr2432525plb.208.1515011149080; Wed, 03 Jan 2018 12:25:49 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1515011149; cv=none; d=google.com; s=arc-20160816; b=iCqOMpgQSLduWKklolviPCOp1U/BHIFPf2hOoww7piYPO5wqNhpolmSmO0W5AY4VYm SK+VD38LULLMMAdQm//r3rsc2p7tP/uSEWNF+RvmVYKIbw8oCAfdjNeXuWLPZx4/yCp6 zQ8IvXVkIv1tGVYxXexe3qbikm8QV6LQ/jqZPCamgqEiTjQZ8iE9E3ly08TQ9edS2072 is3qJO18ohx93KAqoLMKjSIr+2c96cV9ywScBBkYOv0RQEMevyU1zbv5CcIa+9q/TsqZ oPZVDWd+g9ct8rv7muUh3z+giLjykz2RPvWY42EsTcONGZOvPElzTDk5x78OTEWJRCHQ 87fQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:message-id:date :subject:cc:to:from:dkim-signature:arc-authentication-results; bh=yuxNFdqyh9fGOBfXt7ecxjJ/90yWX0zeX2nQ3WuQ6Lc=; b=H4vu+cjHgAFibMZ2APhj5yMRqZxEkarsEdSCZ7dR5UhBwJ3PsvYzjBP4Xjwqh7oyrW FqNwhYDtFRwaXtjiQaUtbjKXmSRrPSQtfP88fnUIFuKfZA186CIWY9xgpRYx45MKj/n7 7F9hBtOPOf8YVQNAZOzatxw20TvEZdW+wuZb8eORpIc9rdQH8o1c4ATm23GmfKG4SgMl C0tV5PTQEqKN2Z5y+Tf/8j9Lr3QMR2cJSlKj3JbOyDxpY26/YKgzV5TS6A6IUvvfLbWp RT8ctWK2pYkcDOK/5/zaP+DFPfKcNBoBCImY9vXvrH4FTUsn0QCTrkK+VufMzdFAnpKh 4zPw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=m3BdYLld; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gmail.com Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id be1si1151096plb.48.2018.01.03.12.25.48; Wed, 03 Jan 2018 12:25:49 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=m3BdYLld; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gmail.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752379AbeACUZq (ORCPT + 28 others); Wed, 3 Jan 2018 15:25:46 -0500 Received: from mail-wr0-f194.google.com ([209.85.128.194]:45851 "EHLO mail-wr0-f194.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752096AbeACUN0 (ORCPT ); Wed, 3 Jan 2018 15:13:26 -0500 Received: by mail-wr0-f194.google.com with SMTP id o15so2834482wrf.12; Wed, 03 Jan 2018 12:13:25 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=yuxNFdqyh9fGOBfXt7ecxjJ/90yWX0zeX2nQ3WuQ6Lc=; b=m3BdYLldQfK/BHxp30G8d50z1sQ8A+0BqTAXBx8XzHZLAr91K8b8rc/0oj/v9pPlmc /zOZHoR7URcYPG9Usq+Q0mlc5jvJM17iRor/TsJaXhk+gMwY1LzonaFpTS+I+tMfYd2l Mmks1e8/Ks9O2Zu98ixqbA/cU6sjRycHHWqM0hcYRPGmCpV4hzSyBgs6cvkAIhH27V/j dplxXtAZ/zJTY0xwEo1vH4cNW+LVOhlCU8CYys/jU/E2ekJwHv+xN6HX0UIwXlWLL0pl tKM9QY0TMefSj4um//Dm2UlRxrcPSwAv0BPydprpt1tUXkGf29ATP4E6CaT6f0eTX28U pCMg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=yuxNFdqyh9fGOBfXt7ecxjJ/90yWX0zeX2nQ3WuQ6Lc=; b=XIPn+x5tq+USFuKLQd/gavlmAto5GkWCKQUx09h2JJeZIef8LsZSE+sP8oY8IT880b lk/mb5TfgpwHpJd1teZb3rErUcTI7HUHPt0EtZXcEqGTnAZWAuZFI5Z4xAMRM1mnAXZ2 4hXQC3rD7rtnFIO/f+H43TrKOg5LuGlzAnKVuqv4Dz/deyCJMgMcmNYN/88aQEzmIkDu LahK5vZ1hrrRhBMZIJ1oMap9uV1bj+AutsoCLvUXk5TrqFzZraHRJfwRNvWqbHt8hI0b 9PO3VBZIBb8KDkqwvY6ZJSC0oil51LJzFYvJMo88WVeOaWDZ3sTGDScvofUGOSmVE4be AvXA== X-Gm-Message-State: AKGB3mI5uySHkxi/ScbUkaKVcLPpjP/fzLODub+X9AwnCUwrkRTgMVw6 6PHF4iEOnyk8m43BYPqrV6c= X-Received: by 10.223.187.130 with SMTP id q2mr2702770wrg.181.1515010405302; Wed, 03 Jan 2018 12:13:25 -0800 (PST) Received: from Red.local (LFbn-1-6953-20.w90-116.abo.wanadoo.fr. [90.116.134.20]) by smtp.googlemail.com with ESMTPSA id p90sm1800627wmf.3.2018.01.03.12.13.23 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 03 Jan 2018 12:13:24 -0800 (PST) From: Corentin Labbe To: alexandre.torgue@st.com, arei.gonglei@huawei.com, corbet@lwn.net, davem@davemloft.net, herbert@gondor.apana.org.au, jasowang@redhat.com, mcoquelin.stm32@gmail.com, mst@redhat.com Cc: linux-arm-kernel@lists.infradead.org, linux-crypto@vger.kernel.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, virtualization@lists.linux-foundation.org, fabien.dessenne@st.com, Corentin Labbe Subject: [PATCH 4/6] crypto: virtio: convert to new crypto engine API Date: Wed, 3 Jan 2018 21:11:07 +0100 Message-Id: <20180103201109.16077-5-clabbe.montjoie@gmail.com> X-Mailer: git-send-email 2.13.6 In-Reply-To: <20180103201109.16077-1-clabbe.montjoie@gmail.com> References: <20180103201109.16077-1-clabbe.montjoie@gmail.com> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This patch convert the driver to the new crypto engine API. Signed-off-by: Corentin Labbe --- drivers/crypto/virtio/virtio_crypto_algs.c | 10 +++++++--- drivers/crypto/virtio/virtio_crypto_common.h | 3 +-- drivers/crypto/virtio/virtio_crypto_core.c | 3 --- 3 files changed, 8 insertions(+), 8 deletions(-) -- 2.13.6 diff --git a/drivers/crypto/virtio/virtio_crypto_algs.c b/drivers/crypto/virtio/virtio_crypto_algs.c index abe8c15450df..060824a8ab0a 100644 --- a/drivers/crypto/virtio/virtio_crypto_algs.c +++ b/drivers/crypto/virtio/virtio_crypto_algs.c @@ -29,6 +29,7 @@ struct virtio_crypto_ablkcipher_ctx { + struct crypto_engine_reqctx enginectx; struct virtio_crypto *vcrypto; struct crypto_tfm *tfm; @@ -521,6 +522,9 @@ static int virtio_crypto_ablkcipher_init(struct crypto_tfm *tfm) tfm->crt_ablkcipher.reqsize = sizeof(struct virtio_crypto_sym_request); ctx->tfm = tfm; + ctx->enginectx.op.do_one_request = virtio_crypto_ablkcipher_crypt_req; + ctx->enginectx.op.prepare_request = NULL; + ctx->enginectx.op.unprepare_request = NULL; return 0; } @@ -538,9 +542,9 @@ static void virtio_crypto_ablkcipher_exit(struct crypto_tfm *tfm) } int virtio_crypto_ablkcipher_crypt_req( - struct crypto_engine *engine, - struct ablkcipher_request *req) + struct crypto_engine *engine, void *vreq) { + struct ablkcipher_request *req = container_of(vreq, struct ablkcipher_request, base); struct virtio_crypto_sym_request *vc_sym_req = ablkcipher_request_ctx(req); struct virtio_crypto_request *vc_req = &vc_sym_req->base; @@ -562,7 +566,7 @@ static void virtio_crypto_ablkcipher_finalize_req( int err) { crypto_finalize_cipher_request(vc_sym_req->base.dataq->engine, - req, err); + req, err); kzfree(vc_sym_req->iv); virtcrypto_clear_request(&vc_sym_req->base); } diff --git a/drivers/crypto/virtio/virtio_crypto_common.h b/drivers/crypto/virtio/virtio_crypto_common.h index e976539a05d9..72621bd67211 100644 --- a/drivers/crypto/virtio/virtio_crypto_common.h +++ b/drivers/crypto/virtio/virtio_crypto_common.h @@ -107,8 +107,7 @@ struct virtio_crypto *virtcrypto_get_dev_node(int node); int virtcrypto_dev_start(struct virtio_crypto *vcrypto); void virtcrypto_dev_stop(struct virtio_crypto *vcrypto); int virtio_crypto_ablkcipher_crypt_req( - struct crypto_engine *engine, - struct ablkcipher_request *req); + struct crypto_engine *engine, void *vreq); void virtcrypto_clear_request(struct virtio_crypto_request *vc_req); diff --git a/drivers/crypto/virtio/virtio_crypto_core.c b/drivers/crypto/virtio/virtio_crypto_core.c index ff1410a32c2b..83326986c113 100644 --- a/drivers/crypto/virtio/virtio_crypto_core.c +++ b/drivers/crypto/virtio/virtio_crypto_core.c @@ -111,9 +111,6 @@ static int virtcrypto_find_vqs(struct virtio_crypto *vi) ret = -ENOMEM; goto err_engine; } - - vi->data_vq[i].engine->cipher_one_request = - virtio_crypto_ablkcipher_crypt_req; } kfree(names); From patchwork Wed Jan 3 20:11:08 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Corentin Labbe X-Patchwork-Id: 123337 Delivered-To: patch@linaro.org Received: by 10.80.135.92 with SMTP id 28csp5926440edv; Wed, 3 Jan 2018 12:25:11 -0800 (PST) X-Google-Smtp-Source: ACJfBovAmZ5wZXkg2kczAROsuWD0QRdiHUlHDCzhpyXS/X3pgXAa1CweMGQCF2q5QPcBWB1b8fIL X-Received: by 10.84.235.204 with SMTP id m12mr2445389plt.84.1515011111730; Wed, 03 Jan 2018 12:25:11 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1515011111; cv=none; d=google.com; s=arc-20160816; b=lqQPAQWzSA+2dHryg46ihQ64RzuvSBl6tGxq83Ibk9GryUtriGf7j6XQwIBmvhHQwj u5gcWUHr/oy5gKfNSvQgE69+pWYH8uHxDGFxeBDuFI+QebMTIQzb+qO+0gr42NUD6XVy 7epZFfM8q82Hz7EtiT7tRjZsrwO9VB8PJi/HtMjJqP8W7yRiI4ZyWk0b7wrH0QPK6Ldw DwhYh5PCSvsq1xHMgFFQw3IlbgVOADwCB3KK+I7bVNIK1f3W5WUaazbrdTCh9Q1VTf4B rMujHGLQzHcBEGXRuGK2MzGAhAMtsrOLeibwmPz5DLDDpvVDMVJrJxX77LMsoD+Kf49M QBeA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:message-id:date :subject:cc:to:from:dkim-signature:arc-authentication-results; bh=+lyLVjEDcCmHazDWRuGxSuP3x/WTn0GZt6pNizNjjRc=; b=iYAJ3sqJtQ+8FO2bUkuS0tzYnFHBSg6MbF8KII8pZqMSfNYRWltAXNG+FQ26o1PD+T 0yuUuVquq2BnHV4M1YxcWQORfOxr4XktBbE6EvaDsCoOezVx4ha/nkStymHgfK4maauq x8xU3T/O/7sPk1jvxDFeKhCyBPIwBwzuaBXLGHWYsH8x6NAlwY/ujZLxftvwXQtsij7q EVCBxUh6E937jH8GvpwD3pEnX7eKxrP5zouzWsZdjub/mpLS8B5i0/n4GPaYtrU9CwN5 f4z5wE7cBgsUWCfNgqssaEgk6du8VDcNHTd2EuAehzgTURDh78cTfBilawX+9CFCWXNR mdIw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=XNUkhoWP; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gmail.com Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id o3si1130539pld.695.2018.01.03.12.25.11; Wed, 03 Jan 2018 12:25:11 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=XNUkhoWP; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gmail.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751451AbeACUZG (ORCPT + 28 others); Wed, 3 Jan 2018 15:25:06 -0500 Received: from mail-wr0-f196.google.com ([209.85.128.196]:42454 "EHLO mail-wr0-f196.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752200AbeACUN2 (ORCPT ); Wed, 3 Jan 2018 15:13:28 -0500 Received: by mail-wr0-f196.google.com with SMTP id w107so2841886wrb.9; Wed, 03 Jan 2018 12:13:27 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=+lyLVjEDcCmHazDWRuGxSuP3x/WTn0GZt6pNizNjjRc=; b=XNUkhoWPZi6vVgZycj4mqzsr0jxf5rA9Tse1R1qzg6ngpJVmcmyklRBBp0gkmhOHDr x0a627QWehs8QcbjtvFmTg3OMW23C+i6dzItzSavd1FbLMt8PwlwSS5u5KlLycXI3tkG sG0NYAV8Em6U63LvBkp0XJV0wCfOIxNVH8S31YNgvlFO0/P4HuMhXyfr6aCy/MulXfhX n3y3aFJAKLFtn+5WiCYn30wXtiK8MAZTw21jl7buCtCZApQT7jZnNc8DrfL83TI6MOWG PZYdXM0zzeekV//lDrdFxck0R0m6qwFd6e/hjM1Qsuvvl020nbmW3lY7zZXswNwMK3ZO RUxQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=+lyLVjEDcCmHazDWRuGxSuP3x/WTn0GZt6pNizNjjRc=; b=VKfx+in7gek1VT8K8uaYT1nmu6fQU+6+42qlaciFG7kHhKhtPOqOJh+AZBKH5TUTqm TpB1PW/to0kNi1GCVR4OmVsDebExjXSuNB+LIy233jKGoLshERaz/NFijnfEDkjxmzdX eL3zzmuoGSuE9687n5PoST0KOIrBrA0nK3oeXefxsze/3YCzPCcR9YpK1Mh4Ns0CTM+/ 7xi5219FVPhEla1gPX7thgJr4h7wR935x2vYm5F5kid8nlpUx2NDJWXLMh8gGDNkfPPB wP/S29ljXGBmiI1htkf5TE2da5kq/ZG8le7mLkIh3pQbgUu9/xNJ0ys4TpORjk+vvR7c JVeg== X-Gm-Message-State: AKGB3mLBdgjnggkHaDsVbJG8v5DIL1NthTHAPPos3uNyKjNHaBrVQFtT wbVg2z3axibtnC679farpkY= X-Received: by 10.223.179.215 with SMTP id x23mr2719698wrd.137.1515010406797; Wed, 03 Jan 2018 12:13:26 -0800 (PST) Received: from Red.local (LFbn-1-6953-20.w90-116.abo.wanadoo.fr. [90.116.134.20]) by smtp.googlemail.com with ESMTPSA id p90sm1800627wmf.3.2018.01.03.12.13.25 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 03 Jan 2018 12:13:26 -0800 (PST) From: Corentin Labbe To: alexandre.torgue@st.com, arei.gonglei@huawei.com, corbet@lwn.net, davem@davemloft.net, herbert@gondor.apana.org.au, jasowang@redhat.com, mcoquelin.stm32@gmail.com, mst@redhat.com Cc: linux-arm-kernel@lists.infradead.org, linux-crypto@vger.kernel.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, virtualization@lists.linux-foundation.org, fabien.dessenne@st.com, Corentin Labbe Subject: [PATCH 5/6] crypto: stm32-hash: convert to the new crypto engine API Date: Wed, 3 Jan 2018 21:11:08 +0100 Message-Id: <20180103201109.16077-6-clabbe.montjoie@gmail.com> X-Mailer: git-send-email 2.13.6 In-Reply-To: <20180103201109.16077-1-clabbe.montjoie@gmail.com> References: <20180103201109.16077-1-clabbe.montjoie@gmail.com> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This patch convert the stm32-hash driver to the new crypto engine API. Signed-off-by: Corentin Labbe --- drivers/crypto/stm32/stm32-hash.c | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) -- 2.13.6 Tested-by: Fabien Dessenne diff --git a/drivers/crypto/stm32/stm32-hash.c b/drivers/crypto/stm32/stm32-hash.c index 4ca4a264a833..9790c2c936c7 100644 --- a/drivers/crypto/stm32/stm32-hash.c +++ b/drivers/crypto/stm32/stm32-hash.c @@ -122,6 +122,7 @@ enum stm32_hash_data_format { #define HASH_DMA_THRESHOLD 50 struct stm32_hash_ctx { + struct crypto_engine_reqctx enginectx; struct stm32_hash_dev *hdev; unsigned long flags; @@ -828,6 +829,11 @@ static int stm32_hash_hw_init(struct stm32_hash_dev *hdev, return 0; } +static int stm32_hash_one_request(struct crypto_engine *engine, + void *areq); +static int stm32_hash_prepare_req(struct crypto_engine *engine, + void *areq); + static int stm32_hash_handle_queue(struct stm32_hash_dev *hdev, struct ahash_request *req) { @@ -835,8 +841,9 @@ static int stm32_hash_handle_queue(struct stm32_hash_dev *hdev, } static int stm32_hash_prepare_req(struct crypto_engine *engine, - struct ahash_request *req) + void *areq) { + struct ahash_request *req = container_of(areq, struct ahash_request, base); struct stm32_hash_ctx *ctx = crypto_ahash_ctx(crypto_ahash_reqtfm(req)); struct stm32_hash_dev *hdev = stm32_hash_find_dev(ctx); struct stm32_hash_request_ctx *rctx; @@ -855,8 +862,9 @@ static int stm32_hash_prepare_req(struct crypto_engine *engine, } static int stm32_hash_one_request(struct crypto_engine *engine, - struct ahash_request *req) + void *areq) { + struct ahash_request *req = container_of(areq, struct ahash_request, base); struct stm32_hash_ctx *ctx = crypto_ahash_ctx(crypto_ahash_reqtfm(req)); struct stm32_hash_dev *hdev = stm32_hash_find_dev(ctx); struct stm32_hash_request_ctx *rctx; @@ -1033,6 +1041,9 @@ static int stm32_hash_cra_init_algs(struct crypto_tfm *tfm, if (algs_hmac_name) ctx->flags |= HASH_FLAGS_HMAC; + ctx->enginectx.op.do_one_request = stm32_hash_one_request; + ctx->enginectx.op.prepare_request = stm32_hash_prepare_req; + ctx->enginectx.op.unprepare_request = NULL; return 0; } @@ -1493,9 +1504,6 @@ static int stm32_hash_probe(struct platform_device *pdev) goto err_engine; } - hdev->engine->prepare_hash_request = stm32_hash_prepare_req; - hdev->engine->hash_one_request = stm32_hash_one_request; - ret = crypto_engine_start(hdev->engine); if (ret) goto err_engine_start; From patchwork Wed Jan 3 20:11:09 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Corentin Labbe X-Patchwork-Id: 123336 Delivered-To: patch@linaro.org Received: by 10.80.135.92 with SMTP id 28csp5925837edv; Wed, 3 Jan 2018 12:24:30 -0800 (PST) X-Google-Smtp-Source: ACJfBotMNFdOezaTeA6kAfBpjVs0fdX8v62glJ6XZXfIPLuate7eNPAmppP0bbMR2MlqTfuHgZo4 X-Received: by 10.159.216.139 with SMTP id s11mr2398347plp.266.1515011070862; Wed, 03 Jan 2018 12:24:30 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1515011070; cv=none; d=google.com; s=arc-20160816; b=N9QEsg5sLNBIotrXKoO6OVY4cZoq+hD1hCBf9WtxENdLa/kl0WUrXB63uty3ujIInD 6VTLIx4WQq6WA7TcEbwqWnh0nSzsDHEiZfEqEhelhRaTnoS2sCYZNZyrJ88aUeBe7O4X J17nD28b6w/rkwpK7jMNViTFBRXIYUDf24cVJIgyvACOyy75383ZivJ88ARznlyAklLE 7OxX1zm38sQ6oqXoP3wCKL3CgH++dhlXU2QFJgTWHhbf9pxKNd21oHv+4oaW5EYIM2RP LSjq2JSR4znhhdSIlMaA2ZPWn4fVk9N+Dc9rSGlnhcqWDFfPQcwWLbomEbOJK8YGJ+0s 9lLw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:message-id:date :subject:cc:to:from:dkim-signature:arc-authentication-results; bh=61Lz+UYQikoQOU/+WcGzqrLew7e/7oUvop+fw0jHhyE=; b=O5bnNM7O1Oqac9O68qRlbfIpenVXiKMuTH2PMxXQ1kLfhFxrMsoFbmTcnLm3IPrFtM R2bmXPp2uCAzKlLztpRjchGmV9m7di8rSNGT4UvcIkSRCH4isZuoQdQ0Ifd9zyDG+YPr W8NdDyRFwMcA7tJqOZonNVw0Adf3q6Q6vsWPNNfEmZHp7DPlNnArr6Yty4adSGrN5OcT LifMSResN7obYq4qlUaQqv/uQALwyw9OFjRBLOS5g3xoPIri4lzpTDDgzDLLCFFNQ/02 Ncxs0tqwp6lGEokMziXcV1ljUt0hA8kj1LwH1+t0fTW4vMHV3Wrilik/OPsYJIuSthrw TKzg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=ay41fxZb; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gmail.com Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id i2si1028956pgs.818.2018.01.03.12.24.30; Wed, 03 Jan 2018 12:24:30 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=ay41fxZb; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gmail.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752261AbeACUNf (ORCPT + 28 others); Wed, 3 Jan 2018 15:13:35 -0500 Received: from mail-wr0-f195.google.com ([209.85.128.195]:33126 "EHLO mail-wr0-f195.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752143AbeACUN3 (ORCPT ); Wed, 3 Jan 2018 15:13:29 -0500 Received: by mail-wr0-f195.google.com with SMTP id p6so403775wrd.0; Wed, 03 Jan 2018 12:13:28 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=61Lz+UYQikoQOU/+WcGzqrLew7e/7oUvop+fw0jHhyE=; b=ay41fxZbYE5Zw46uNNKp63irzsFepZiXoTrMLuNbQtC48YVC7xfasdf+6qaJsCSfAI 8dSVFUi7Z8564LvgjL1+DWPA4ciYxaMGlM1plHnJ4LODPWOAjlOdKiwzGuG0tWHHiu3g SWSH96OVMfnDIoyIh3PnMR5gKneHN0vH/YTFzv1lsHUQYoNvGA1NvWpFn6NEVKwzKxSJ 5ZrjIUnsYGOWmFARFj8IpfZ93yIQPinE8ATuW/kRk3zG0DX3HR3a4nWYZVvstrKGn8+Q mRn5i0ZMiQU+yKVFFU2z5MJ0P3DIkyisyQw4yByjz5g2w77aeArHySno7TorjCoHwfsU KSiw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=61Lz+UYQikoQOU/+WcGzqrLew7e/7oUvop+fw0jHhyE=; b=geCsmGiOrSUsSySUgFYXuKG3K/4SHLkSEiM3XRxtabMixpGZlvltWgBNTUwjAx4NEb BgYnMhJ6cdpKX5QrZaPljhWZrEc4yt4r4+WSNgx2LocwvoIAU+UfWEuF+YcP6/1CIDdu 8yxAG2VHTDTor5Vdxsr+MdtPvhGAdX04yObdCVN+DRlqeR06Tzlnd66y0RUQ31LzmlzK TNu17BdxYJNaeu2ygTYLX2Wum8cKZFEzfCCnKyAnEZgw/xkqWEbuHKtTyOhgxl/32GR5 utZsrXK8pBcsBeyKOTizefTKgmWA1hNvFnBYPCLhHGPuAF8mqIM9Do5MwPAByJ00bk34 l/dA== X-Gm-Message-State: AKGB3mK2YGRI4sL7am0+x4eEPVtVb868qgCP8DWajYAtBOyKFxOYV9oU ChK/9YqTRzc9p1Kbk1mhrYuSkRL8 X-Received: by 10.223.169.231 with SMTP id b94mr2747397wrd.63.1515010408190; Wed, 03 Jan 2018 12:13:28 -0800 (PST) Received: from Red.local (LFbn-1-6953-20.w90-116.abo.wanadoo.fr. [90.116.134.20]) by smtp.googlemail.com with ESMTPSA id p90sm1800627wmf.3.2018.01.03.12.13.26 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 03 Jan 2018 12:13:27 -0800 (PST) From: Corentin Labbe To: alexandre.torgue@st.com, arei.gonglei@huawei.com, corbet@lwn.net, davem@davemloft.net, herbert@gondor.apana.org.au, jasowang@redhat.com, mcoquelin.stm32@gmail.com, mst@redhat.com Cc: linux-arm-kernel@lists.infradead.org, linux-crypto@vger.kernel.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, virtualization@lists.linux-foundation.org, fabien.dessenne@st.com, Corentin Labbe Subject: [PATCH 6/6] crypto: stm32-cryp: convert to the new crypto engine API Date: Wed, 3 Jan 2018 21:11:09 +0100 Message-Id: <20180103201109.16077-7-clabbe.montjoie@gmail.com> X-Mailer: git-send-email 2.13.6 In-Reply-To: <20180103201109.16077-1-clabbe.montjoie@gmail.com> References: <20180103201109.16077-1-clabbe.montjoie@gmail.com> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This patch convert the stm32-cryp driver to the new crypto engine API. Signed-off-by: Corentin Labbe --- drivers/crypto/stm32/stm32-cryp.c | 21 ++++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-) -- 2.13.6 diff --git a/drivers/crypto/stm32/stm32-cryp.c b/drivers/crypto/stm32/stm32-cryp.c index cf1dddbeaa2c..99e0473ef247 100644 --- a/drivers/crypto/stm32/stm32-cryp.c +++ b/drivers/crypto/stm32/stm32-cryp.c @@ -91,6 +91,7 @@ #define _walked_out (cryp->out_walk.offset - cryp->out_sg->offset) struct stm32_cryp_ctx { + struct crypto_engine_reqctx enginectx; struct stm32_cryp *cryp; int keylen; u32 key[AES_KEYSIZE_256 / sizeof(u32)]; @@ -494,10 +495,20 @@ static int stm32_cryp_cpu_start(struct stm32_cryp *cryp) return 0; } +static int stm32_cryp_cipher_one_req(struct crypto_engine *engine, + void *areq); +static int stm32_cryp_prepare_cipher_req(struct crypto_engine *engine, + void *areq); + static int stm32_cryp_cra_init(struct crypto_tfm *tfm) { + struct stm32_cryp_ctx *ctx = crypto_tfm_ctx(tfm); + tfm->crt_ablkcipher.reqsize = sizeof(struct stm32_cryp_reqctx); + ctx->enginectx.op.do_one_request = stm32_cryp_cipher_one_req; + ctx->enginectx.op.prepare_request = stm32_cryp_prepare_cipher_req; + ctx->enginectx.op.unprepare_request = NULL; return 0; } @@ -695,14 +706,17 @@ static int stm32_cryp_prepare_req(struct crypto_engine *engine, } static int stm32_cryp_prepare_cipher_req(struct crypto_engine *engine, - struct ablkcipher_request *req) + void *areq) { + struct ablkcipher_request *req = container_of(areq, struct ablkcipher_request, base); + return stm32_cryp_prepare_req(engine, req); } static int stm32_cryp_cipher_one_req(struct crypto_engine *engine, - struct ablkcipher_request *req) + void *areq) { + struct ablkcipher_request *req = container_of(areq, struct ablkcipher_request, base); struct stm32_cryp_ctx *ctx = crypto_ablkcipher_ctx( crypto_ablkcipher_reqtfm(req)); struct stm32_cryp *cryp = ctx->cryp; @@ -1104,9 +1118,6 @@ static int stm32_cryp_probe(struct platform_device *pdev) goto err_engine1; } - cryp->engine->prepare_cipher_request = stm32_cryp_prepare_cipher_req; - cryp->engine->cipher_one_request = stm32_cryp_cipher_one_req; - ret = crypto_engine_start(cryp->engine); if (ret) { dev_err(dev, "Could not start crypto engine\n");