github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-07-27 09:36:22 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

crypto: talitos/hash - drop workqueue mechanism for SEC1

Browse Source 
Now that SEC1 hash uses hardware descriptor chaining instead of a
workqueue to process requests exceeding TALITOS1_MAX_DATA_LEN, the
workqueue code is no longer needed.

Remove sec1_ahash_process_remaining(), the related fields from
talitos_ahash_req_ctx (request_bufsl, areq, request_sl,
remaining_ahash_request_bytes, current_ahash_request_bytes,
sec1_ahash_process_remaining), the dead code in ahash_done(), and
simplify ahash_process_req() to call ahash_process_req_one() directly
with the original areq->src and areq->nbytes.

Cc: stable@vger.kernel.org
Signed-off-by: Paul Louvel <paul.louvel@bootlin.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
This commit is contained in:
Paul Louvel 2026-05-07 16:41:54 +02:00 committed by Herbert Xu
parent f1ede6d95d
commit be4802afb1
1 changed files with 7 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
drivers/crypto/talitos.c
View File

@ -12,7 +12,6 @@
* All rights reserved.
*/
#include <linux/workqueue.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mod_devicetable.h>
@ -952,13 +951,6 @@ struct talitos_ahash_req_ctx {
unsigned int nbuf;
struct scatterlist bufsl[2];
struct scatterlist *psrc;
struct scatterlist request_bufsl[2];
struct ahash_request *areq;
struct scatterlist *request_sl;
unsigned int remaining_ahash_request_bytes;
unsigned int current_ahash_request_bytes;
struct work_struct sec1_ahash_process_remaining;
};
struct talitos_export_state {
@ -1840,18 +1832,6 @@ static void ahash_done(struct device *dev,
free_edesc_list_from(areq, edesc);
ahash_request_complete(areq, err);
return;
req_ctx->remaining_ahash_request_bytes -=
req_ctx->current_ahash_request_bytes;
if (!req_ctx->remaining_ahash_request_bytes) {
ahash_request_complete(areq, 0);
return;
}
schedule_work(&req_ctx->sec1_ahash_process_remaining);
}
/*
@ -2044,12 +2024,12 @@ static int ahash_process_req_one(struct ahash_request *areq, unsigned int nbytes
if (!req_ctx->last_request && (nbytes + req_ctx->nbuf <= blocksize)) {
/* Buffer up to one whole block */
nents = sg_nents_for_len(req_ctx->request_sl, nbytes);
nents = sg_nents_for_len(areq->src, nbytes);
if (nents < 0) {
dev_err(dev, "Invalid number of src SG.\n");
return nents;
}
sg_copy_to_buffer(req_ctx->request_sl, nents,
sg_copy_to_buffer(areq->src, nents,
ctx_buf + req_ctx->nbuf, nbytes);
req_ctx->nbuf += nbytes;
return 0;
@ -2076,18 +2056,18 @@ static int ahash_process_req_one(struct ahash_request *areq, unsigned int nbytes
sg_init_table(req_ctx->bufsl, nsg);
sg_set_buf(req_ctx->bufsl, ctx_buf, req_ctx->nbuf);
if (nsg > 1)
sg_chain(req_ctx->bufsl, 2, req_ctx->request_sl);
sg_chain(req_ctx->bufsl, 2, areq->src);
req_ctx->psrc = req_ctx->bufsl;
} else
req_ctx->psrc = req_ctx->request_sl;
req_ctx->psrc = areq->src;
if (to_hash_later) {
nents = sg_nents_for_len(req_ctx->request_sl, nbytes);
nents = sg_nents_for_len(areq->src, nbytes);
if (nents < 0) {
dev_err(dev, "Invalid number of src SG.\n");
return nents;
}
sg_pcopy_to_buffer(req_ctx->request_sl, nents,
sg_pcopy_to_buffer(areq->src, nents,
req_ctx->buf[(req_ctx->buf_idx + 1) & 1],
to_hash_later,
nbytes - to_hash_later);
@ -2106,54 +2086,9 @@ static int ahash_process_req_one(struct ahash_request *areq, unsigned int nbytes
return ret;
}
static void sec1_ahash_process_remaining(struct work_struct *work)
{
struct talitos_ahash_req_ctx *req_ctx =
container_of(work, struct talitos_ahash_req_ctx,
sec1_ahash_process_remaining);
int err = 0;
req_ctx->request_sl = scatterwalk_ffwd(req_ctx->request_bufsl,
req_ctx->request_sl, TALITOS1_MAX_DATA_LEN);
if (req_ctx->remaining_ahash_request_bytes > TALITOS1_MAX_DATA_LEN)
req_ctx->current_ahash_request_bytes = TALITOS1_MAX_DATA_LEN;
else {
req_ctx->current_ahash_request_bytes =
req_ctx->remaining_ahash_request_bytes;
if (req_ctx->last_request)
req_ctx->last_desc = 1;
}
err = ahash_process_req_one(req_ctx->areq,
req_ctx->current_ahash_request_bytes);
if (err != -EINPROGRESS)
ahash_request_complete(req_ctx->areq, err);
}
static int ahash_process_req(struct ahash_request *areq, unsigned int nbytes)
{
struct crypto_ahash *tfm = crypto_ahash_reqtfm(areq);
struct talitos_ctx *ctx = crypto_ahash_ctx(tfm);
struct device *dev = ctx->dev;
struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq);
struct talitos_private *priv = dev_get_drvdata(dev);
bool is_sec1 = has_ftr_sec1(priv);
req_ctx->areq = areq;
req_ctx->request_sl = areq->src;
req_ctx->remaining_ahash_request_bytes = nbytes;
if (is_sec1) {
if (req_ctx->last_request)
req_ctx->last_desc = 1;
}
req_ctx->current_ahash_request_bytes = nbytes;
return ahash_process_req_one(req_ctx->areq, nbytes);
return ahash_process_req_one(areq, nbytes);
}
static int ahash_init(struct ahash_request *areq)
@ -2176,7 +2111,6 @@ static int ahash_init(struct ahash_request *areq)
req_ctx->hw_context_size = size;
req_ctx->last_request = 0;
req_ctx->last_desc = 0;
INIT_WORK(&req_ctx->sec1_ahash_process_remaining, sec1_ahash_process_remaining);
dma = dma_map_single(dev, req_ctx->hw_context, req_ctx->hw_context_size,
DMA_TO_DEVICE);