From nobody Tue Sep 9 21:31:37 2025 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 33A1EC6FD1F for ; Sat, 11 Mar 2023 09:43:02 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230519AbjCKJnA (ORCPT ); Sat, 11 Mar 2023 04:43:00 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:54682 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230224AbjCKJm0 (ORCPT ); Sat, 11 Mar 2023 04:42:26 -0500 Received: from 167-179-156-38.a7b39c.syd.nbn.aussiebb.net (167-179-156-38.a7b39c.syd.nbn.aussiebb.net [167.179.156.38]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 90B3513FF03; Sat, 11 Mar 2023 01:42:21 -0800 (PST) Received: from loth.rohan.me.apana.org.au ([192.168.167.2]) by formenos.hmeau.com with smtp (Exim 4.94.2 #2 (Debian)) id 1pavE7-002xaw-AF; Sat, 11 Mar 2023 17:09:20 +0800 Received: by loth.rohan.me.apana.org.au (sSMTP sendmail emulation); Sat, 11 Mar 2023 17:09:19 +0800 From: "Herbert Xu" Date: Sat, 11 Mar 2023 17:09:19 +0800 Subject: [v7 PATCH 5/8] crypto: stm32 - Move hash state into separate structure References: To: Linus Walleij , Lionel Debieve , Li kunyu , davem@davemloft.net, linux-arm-kernel@lists.infradead.org, linux-crypto@vger.kernel.org, linux-kernel@vger.kernel.org, linux-stm32@st-md-mailman.stormreply.com, mcoquelin.stm32@gmail.com Message-Id: Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Create a new struct stm32_hash_state so that it may be exported in future instead of the entire request context. Reviewed-by: Linus Walleij Tested-by: Linus Walleij Signed-off-by: Herbert Xu --- drivers/crypto/stm32/stm32-hash.c | 127 +++++++++++++++++++++------------= ----- 1 file changed, 71 insertions(+), 56 deletions(-) diff --git a/drivers/crypto/stm32/stm32-hash.c b/drivers/crypto/stm32/stm32= -hash.c index e35fee945371..c836163a9fd4 100644 --- a/drivers/crypto/stm32/stm32-hash.c +++ b/drivers/crypto/stm32/stm32-hash.c @@ -126,15 +126,24 @@ struct stm32_hash_ctx { int keylen; }; =20 +struct stm32_hash_state { + u32 flags; + + u16 bufcnt; + u16 buflen; + + u8 buffer[HASH_BUFLEN] __aligned(4); + + /* hash state */ + u32 *hw_context; +}; + struct stm32_hash_request_ctx { struct stm32_hash_dev *hdev; - unsigned long flags; unsigned long op; =20 u8 digest[SHA256_DIGEST_SIZE] __aligned(sizeof(u32)); size_t digcnt; - size_t bufcnt; - size_t buflen; =20 /* DMA */ struct scatterlist *sg; @@ -148,10 +157,7 @@ struct stm32_hash_request_ctx { =20 u8 data_type; =20 - u8 buffer[HASH_BUFLEN] __aligned(sizeof(u32)); - - /* Export Context */ - u32 *hw_context; + struct stm32_hash_state state; }; =20 struct stm32_hash_algs_info { @@ -268,11 +274,12 @@ static void stm32_hash_write_ctrl(struct stm32_hash_d= ev *hdev, int bufcnt) struct stm32_hash_request_ctx *rctx =3D ahash_request_ctx(hdev->req); struct crypto_ahash *tfm =3D crypto_ahash_reqtfm(hdev->req); struct stm32_hash_ctx *ctx =3D crypto_ahash_ctx(tfm); + struct stm32_hash_state *state =3D &rctx->state; =20 u32 reg =3D HASH_CR_INIT; =20 if (!(hdev->flags & HASH_FLAGS_INIT)) { - switch (rctx->flags & HASH_FLAGS_ALGO_MASK) { + switch (state->flags & HASH_FLAGS_ALGO_MASK) { case HASH_FLAGS_MD5: reg |=3D HASH_CR_ALGO_MD5; break; @@ -297,7 +304,7 @@ static void stm32_hash_write_ctrl(struct stm32_hash_dev= *hdev, int bufcnt) =20 reg |=3D (rctx->data_type << HASH_CR_DATATYPE_POS); =20 - if (rctx->flags & HASH_FLAGS_HMAC) { + if (state->flags & HASH_FLAGS_HMAC) { hdev->flags |=3D HASH_FLAGS_HMAC; reg |=3D HASH_CR_MODE; if (ctx->keylen > HASH_LONG_KEY) @@ -324,11 +331,12 @@ static void stm32_hash_write_ctrl(struct stm32_hash_d= ev *hdev, int bufcnt) =20 static void stm32_hash_append_sg(struct stm32_hash_request_ctx *rctx) { + struct stm32_hash_state *state =3D &rctx->state; size_t count; =20 - while ((rctx->bufcnt < rctx->buflen) && rctx->total) { + while ((state->bufcnt < state->buflen) && rctx->total) { count =3D min(rctx->sg->length - rctx->offset, rctx->total); - count =3D min(count, rctx->buflen - rctx->bufcnt); + count =3D min_t(size_t, count, state->buflen - state->bufcnt); =20 if (count <=3D 0) { if ((rctx->sg->length =3D=3D 0) && !sg_is_last(rctx->sg)) { @@ -339,10 +347,10 @@ static void stm32_hash_append_sg(struct stm32_hash_re= quest_ctx *rctx) } } =20 - scatterwalk_map_and_copy(rctx->buffer + rctx->bufcnt, rctx->sg, - rctx->offset, count, 0); + scatterwalk_map_and_copy(state->buffer + state->bufcnt, + rctx->sg, rctx->offset, count, 0); =20 - rctx->bufcnt +=3D count; + state->bufcnt +=3D count; rctx->offset +=3D count; rctx->total -=3D count; =20 @@ -411,18 +419,19 @@ static int stm32_hash_xmit_cpu(struct stm32_hash_dev = *hdev, static int stm32_hash_update_cpu(struct stm32_hash_dev *hdev) { struct stm32_hash_request_ctx *rctx =3D ahash_request_ctx(hdev->req); + struct stm32_hash_state *state =3D &rctx->state; int bufcnt, err =3D 0, final; =20 - dev_dbg(hdev->dev, "%s flags %lx\n", __func__, rctx->flags); + dev_dbg(hdev->dev, "%s flags %x\n", __func__, state->flags); =20 - final =3D rctx->flags & HASH_FLAGS_FINAL; + final =3D state->flags & HASH_FLAGS_FINAL; =20 - while ((rctx->total >=3D rctx->buflen) || - (rctx->bufcnt + rctx->total >=3D rctx->buflen)) { + while ((rctx->total >=3D state->buflen) || + (state->bufcnt + rctx->total >=3D state->buflen)) { stm32_hash_append_sg(rctx); - bufcnt =3D rctx->bufcnt; - rctx->bufcnt =3D 0; - err =3D stm32_hash_xmit_cpu(hdev, rctx->buffer, bufcnt, 0); + bufcnt =3D state->bufcnt; + state->bufcnt =3D 0; + err =3D stm32_hash_xmit_cpu(hdev, state->buffer, bufcnt, 0); if (err) return err; } @@ -430,9 +439,9 @@ static int stm32_hash_update_cpu(struct stm32_hash_dev = *hdev) stm32_hash_append_sg(rctx); =20 if (final) { - bufcnt =3D rctx->bufcnt; - rctx->bufcnt =3D 0; - err =3D stm32_hash_xmit_cpu(hdev, rctx->buffer, bufcnt, 1); + bufcnt =3D state->bufcnt; + state->bufcnt =3D 0; + err =3D stm32_hash_xmit_cpu(hdev, state->buffer, bufcnt, 1); } =20 return err; @@ -576,10 +585,10 @@ static int stm32_hash_dma_init(struct stm32_hash_dev = *hdev) static int stm32_hash_dma_send(struct stm32_hash_dev *hdev) { struct stm32_hash_request_ctx *rctx =3D ahash_request_ctx(hdev->req); + u32 *buffer =3D (void *)rctx->state.buffer; struct scatterlist sg[1], *tsg; int err =3D 0, len =3D 0, reg, ncp =3D 0; unsigned int i; - u32 *buffer =3D (void *)rctx->buffer; =20 rctx->sg =3D hdev->req->src; rctx->total =3D hdev->req->nbytes; @@ -607,7 +616,7 @@ static int stm32_hash_dma_send(struct stm32_hash_dev *h= dev) =20 ncp =3D sg_pcopy_to_buffer( rctx->sg, rctx->nents, - rctx->buffer, sg->length - len, + rctx->state.buffer, sg->length - len, rctx->total - sg->length + len); =20 sg->length =3D len; @@ -718,41 +727,40 @@ static int stm32_hash_init(struct ahash_request *req) struct stm32_hash_ctx *ctx =3D crypto_ahash_ctx(tfm); struct stm32_hash_request_ctx *rctx =3D ahash_request_ctx(req); struct stm32_hash_dev *hdev =3D stm32_hash_find_dev(ctx); + struct stm32_hash_state *state =3D &rctx->state; =20 rctx->hdev =3D hdev; =20 - rctx->flags =3D HASH_FLAGS_CPU; + state->flags =3D HASH_FLAGS_CPU; =20 rctx->digcnt =3D crypto_ahash_digestsize(tfm); switch (rctx->digcnt) { case MD5_DIGEST_SIZE: - rctx->flags |=3D HASH_FLAGS_MD5; + state->flags |=3D HASH_FLAGS_MD5; break; case SHA1_DIGEST_SIZE: - rctx->flags |=3D HASH_FLAGS_SHA1; + state->flags |=3D HASH_FLAGS_SHA1; break; case SHA224_DIGEST_SIZE: - rctx->flags |=3D HASH_FLAGS_SHA224; + state->flags |=3D HASH_FLAGS_SHA224; break; case SHA256_DIGEST_SIZE: - rctx->flags |=3D HASH_FLAGS_SHA256; + state->flags |=3D HASH_FLAGS_SHA256; break; default: return -EINVAL; } =20 - rctx->bufcnt =3D 0; - rctx->buflen =3D HASH_BUFLEN; + rctx->state.bufcnt =3D 0; + rctx->state.buflen =3D HASH_BUFLEN; rctx->total =3D 0; rctx->offset =3D 0; rctx->data_type =3D HASH_DATA_8_BITS; =20 - memset(rctx->buffer, 0, HASH_BUFLEN); - if (ctx->flags & HASH_FLAGS_HMAC) - rctx->flags |=3D HASH_FLAGS_HMAC; + state->flags |=3D HASH_FLAGS_HMAC; =20 - dev_dbg(hdev->dev, "%s Flags %lx\n", __func__, rctx->flags); + dev_dbg(hdev->dev, "%s Flags %x\n", __func__, state->flags); =20 return 0; } @@ -760,8 +768,9 @@ static int stm32_hash_init(struct ahash_request *req) static int stm32_hash_update_req(struct stm32_hash_dev *hdev) { struct stm32_hash_request_ctx *rctx =3D ahash_request_ctx(hdev->req); + struct stm32_hash_state *state =3D &rctx->state; =20 - if (!(rctx->flags & HASH_FLAGS_CPU)) + if (!(state->flags & HASH_FLAGS_CPU)) return stm32_hash_dma_send(hdev); =20 return stm32_hash_update_cpu(hdev); @@ -771,14 +780,15 @@ static int stm32_hash_final_req(struct stm32_hash_dev= *hdev) { struct ahash_request *req =3D hdev->req; struct stm32_hash_request_ctx *rctx =3D ahash_request_ctx(req); - int buflen =3D rctx->bufcnt; + struct stm32_hash_state *state =3D &rctx->state; + int buflen =3D state->bufcnt; =20 - if (rctx->flags & HASH_FLAGS_FINUP) + if (state->flags & HASH_FLAGS_FINUP) return stm32_hash_update_req(hdev); =20 - rctx->bufcnt =3D 0; + state->bufcnt =3D 0; =20 - return stm32_hash_xmit_cpu(hdev, rctx->buffer, buflen, 1); + return stm32_hash_xmit_cpu(hdev, state->buffer, buflen, 1); } =20 static void stm32_hash_emptymsg_fallback(struct ahash_request *req) @@ -813,6 +823,7 @@ static void stm32_hash_emptymsg_fallback(struct ahash_r= equest *req) static void stm32_hash_copy_hash(struct ahash_request *req) { struct stm32_hash_request_ctx *rctx =3D ahash_request_ctx(req); + struct stm32_hash_state *state =3D &rctx->state; struct stm32_hash_dev *hdev =3D rctx->hdev; __be32 *hash =3D (void *)rctx->digest; unsigned int i, hashsize; @@ -820,7 +831,7 @@ static void stm32_hash_copy_hash(struct ahash_request *= req) if (hdev->pdata->broken_emptymsg && !req->nbytes) return stm32_hash_emptymsg_fallback(req); =20 - switch (rctx->flags & HASH_FLAGS_ALGO_MASK) { + switch (state->flags & HASH_FLAGS_ALGO_MASK) { case HASH_FLAGS_MD5: hashsize =3D MD5_DIGEST_SIZE; break; @@ -862,6 +873,7 @@ static int stm32_hash_finish(struct ahash_request *req) static void stm32_hash_finish_req(struct ahash_request *req, int err) { struct stm32_hash_request_ctx *rctx =3D ahash_request_ctx(req); + struct stm32_hash_state *state =3D &rctx->state; struct stm32_hash_dev *hdev =3D rctx->hdev; =20 if (!err && (HASH_FLAGS_FINAL & hdev->flags)) { @@ -873,7 +885,7 @@ static void stm32_hash_finish_req(struct ahash_request = *req, int err) HASH_FLAGS_HMAC_INIT | HASH_FLAGS_HMAC_FINAL | HASH_FLAGS_HMAC_KEY); } else { - rctx->flags |=3D HASH_FLAGS_ERRORS; + state->flags |=3D HASH_FLAGS_ERRORS; } =20 pm_runtime_mark_last_busy(hdev->dev); @@ -979,15 +991,16 @@ static int stm32_hash_enqueue(struct ahash_request *r= eq, unsigned int op) static int stm32_hash_update(struct ahash_request *req) { struct stm32_hash_request_ctx *rctx =3D ahash_request_ctx(req); + struct stm32_hash_state *state =3D &rctx->state; =20 - if (!req->nbytes || !(rctx->flags & HASH_FLAGS_CPU)) + if (!req->nbytes || !(state->flags & HASH_FLAGS_CPU)) return 0; =20 rctx->total =3D req->nbytes; rctx->sg =3D req->src; rctx->offset =3D 0; =20 - if ((rctx->bufcnt + rctx->total < rctx->buflen)) { + if ((state->bufcnt + rctx->total < state->buflen)) { stm32_hash_append_sg(rctx); return 0; } @@ -998,8 +1011,9 @@ static int stm32_hash_update(struct ahash_request *req) static int stm32_hash_final(struct ahash_request *req) { struct stm32_hash_request_ctx *rctx =3D ahash_request_ctx(req); + struct stm32_hash_state *state =3D &rctx->state; =20 - rctx->flags |=3D HASH_FLAGS_FINAL; + state->flags |=3D HASH_FLAGS_FINAL; =20 return stm32_hash_enqueue(req, HASH_OP_FINAL); } @@ -1009,17 +1023,18 @@ static int stm32_hash_finup(struct ahash_request *r= eq) struct stm32_hash_request_ctx *rctx =3D ahash_request_ctx(req); struct stm32_hash_ctx *ctx =3D crypto_ahash_ctx(crypto_ahash_reqtfm(req)); struct stm32_hash_dev *hdev =3D stm32_hash_find_dev(ctx); + struct stm32_hash_state *state =3D &rctx->state; =20 if (!req->nbytes) goto out; =20 - rctx->flags |=3D HASH_FLAGS_FINUP; + state->flags |=3D HASH_FLAGS_FINUP; rctx->total =3D req->nbytes; rctx->sg =3D req->src; rctx->offset =3D 0; =20 if (hdev->dma_lch && stm32_hash_dma_aligned_data(req)) - rctx->flags &=3D ~HASH_FLAGS_CPU; + state->flags &=3D ~HASH_FLAGS_CPU; =20 out: return stm32_hash_final(req); @@ -1035,6 +1050,7 @@ static int stm32_hash_export(struct ahash_request *re= q, void *out) struct stm32_hash_request_ctx *rctx =3D ahash_request_ctx(req); struct stm32_hash_ctx *ctx =3D crypto_ahash_ctx(crypto_ahash_reqtfm(req)); struct stm32_hash_dev *hdev =3D stm32_hash_find_dev(ctx); + struct stm32_hash_state *state =3D &rctx->state; u32 *preg; unsigned int i; int ret; @@ -1045,11 +1061,9 @@ static int stm32_hash_export(struct ahash_request *r= eq, void *out) if (ret) return ret; =20 - rctx->hw_context =3D kmalloc_array(3 + HASH_CSR_REGISTER_NUMBER, - sizeof(u32), - GFP_KERNEL); - - preg =3D rctx->hw_context; + state->hw_context =3D kmalloc_array(3 + HASH_CSR_REGISTER_NUMBER, + sizeof(u32), GFP_KERNEL); + preg =3D state->hw_context; =20 if (!hdev->pdata->ux500) *preg++ =3D stm32_hash_read(hdev, HASH_IMR); @@ -1071,13 +1085,14 @@ static int stm32_hash_import(struct ahash_request *= req, const void *in) struct stm32_hash_request_ctx *rctx =3D ahash_request_ctx(req); struct stm32_hash_ctx *ctx =3D crypto_ahash_ctx(crypto_ahash_reqtfm(req)); struct stm32_hash_dev *hdev =3D stm32_hash_find_dev(ctx); + struct stm32_hash_state *state =3D &rctx->state; const u32 *preg =3D in; u32 reg; unsigned int i; =20 memcpy(rctx, in, sizeof(*rctx)); =20 - preg =3D rctx->hw_context; + preg =3D state->hw_context; =20 pm_runtime_get_sync(hdev->dev); =20 @@ -1094,7 +1109,7 @@ static int stm32_hash_import(struct ahash_request *re= q, const void *in) pm_runtime_mark_last_busy(hdev->dev); pm_runtime_put_autosuspend(hdev->dev); =20 - kfree(rctx->hw_context); + kfree(state->hw_context); =20 return 0; }