crypto: talitos/hash - drop workqueue mechanism for SEC1

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>

diff --git a/drivers/crypto/talitos.c b/drivers/crypto/talitos.c
index 5f8ee1f1346f947e4c61bb050c69de3ccbbb0018..fe38bc6aaaab3721b03c6b447a4f07db4b225ff4 100644 (file)
--- a/drivers/crypto/talitos.c
+++ b/drivers/crypto/talitos.c
@@ -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);